diff --git a/actions/publishToPublication.ts b/actions/publishToPublication.ts
index 4f7e8b38..4b94bec4 100644
--- a/actions/publishToPublication.ts
+++ b/actions/publishToPublication.ts
@@ -39,7 +39,7 @@ import { AtUri } from "@atproto/syntax";
 import { Json } from "supabase/database.types";
 import { $Typed, UnicodeString } from "@atproto/api";
 import { List, parseBlocksToList } from "src/utils/parseBlocksToList";
-import { getBlocksWithTypeLocal } from "src/hooks/queries/useBlocks";
+import { getBlocksWithTypeLocal } from "src/replicache/getBlocks";
 import { Lock } from "src/utils/lock";
 import type { PubLeafletPublication } from "lexicons/api";
 import {
diff --git a/actions/subscriptions/subscribeToMailboxWithEmail.ts b/actions/subscriptions/subscribeToMailboxWithEmail.ts
index 7f145132..4117bc56 100644
--- a/actions/subscriptions/subscribeToMailboxWithEmail.ts
+++ b/actions/subscriptions/subscribeToMailboxWithEmail.ts
@@ -6,7 +6,7 @@ import { and, eq } from "drizzle-orm";
 import { drizzle } from "drizzle-orm/node-postgres";
 import { email_subscriptions_to_entity } from "drizzle/schema";
 import postgres from "postgres";
-import { getBlocksWithTypeLocal } from "src/hooks/queries/useBlocks";
+import { getBlocksWithTypeLocal } from "src/replicache/getBlocks";
 import type { Fact, PermissionToken } from "src/replicache";
 import type { Attribute } from "src/replicache/attributes";
 import { Database } from "supabase/database.types";
diff --git a/components/Blocks/Block.tsx b/components/Blocks/Block.tsx
index 64efceec..91a7ec75 100644
--- a/components/Blocks/Block.tsx
+++ b/components/Blocks/Block.tsx
@@ -33,6 +33,7 @@ import { HorizontalRule } from "./HorizontalRule";
 import { deepEquals } from "src/utils/deepEquals";
 import { isTextBlock } from "src/utils/isTextBlock";
 import { focusPage } from "src/utils/focusPage";
+import { getBlocksWithType } from "src/replicache/getBlocks";
 
 export type Block = {
   factID: string;
@@ -42,6 +43,8 @@ export type Block = {
   type: Fact<"block/type">["data"]["value"];
   listData?: {
     checklist?: boolean;
+    listStyle?: "ordered" | "unordered";
+    listNumber?: number;
     path: { depth: number; entity: string }[];
     parent: string;
     depth: number;
@@ -172,7 +175,9 @@ function deepEqualsBlockProps(
     if (
       prevProps.listData.checklist !== nextProps.listData.checklist ||
       prevProps.listData.parent !== nextProps.listData.parent ||
-      prevProps.listData.depth !== nextProps.listData.depth
+      prevProps.listData.depth !== nextProps.listData.depth ||
+      prevProps.listData.listNumber !== nextProps.listData.listNumber ||
+      prevProps.listData.listStyle !== nextProps.listData.listStyle
     ) {
       return false;
     }
@@ -420,6 +425,7 @@ export const ListMarker = (
 ) => {
   let isMobile = useIsMobile();
   let checklist = useEntity(props.value, "block/check-list");
+  let listStyle = useEntity(props.value, "block/list-style");
   let headingLevel = useEntity(props.value, "block/heading-level")?.data.value;
   let children = useEntity(props.value, "card/block");
   let folded =
@@ -429,6 +435,62 @@ export const ListMarker = (
   let depth = props.listData?.depth;
   let { permissions } = useEntitySetContext();
   let { rep } = useReplicache();
+
+  let [editingNumber, setEditingNumber] = useState(false);
+  let [numberInputValue, setNumberInputValue] = useState("");
+
+  useEffect(() => {
+    if (!editingNumber) {
+      setNumberInputValue("");
+    }
+  }, [editingNumber]);
+
+  const handleNumberSave = async () => {
+    if (!rep || !props.listData) return;
+
+    const newNumber = parseInt(numberInputValue, 10);
+    if (isNaN(newNumber) || newNumber < 1) {
+      setEditingNumber(false);
+      return;
+    }
+
+    const oldNumber = props.listData.listNumber || 1;
+    const difference = newNumber - oldNumber;
+
+    if (difference === 0) {
+      setEditingNumber(false);
+      return;
+    }
+
+    // Update this block's number
+    await rep.mutate.assertFact({
+      entity: props.value,
+      attribute: "block/list-number",
+      data: { type: "number", value: newNumber },
+    });
+
+    // Cascade to following blocks at the same depth
+    const allBlocks = await rep.query((tx) => getBlocksWithType(tx, props.parent));
+    if (allBlocks) {
+      const currentIndex = allBlocks.findIndex((b) => b.value === props.value);
+      for (let i = currentIndex + 1; i < allBlocks.length; i++) {
+        const block = allBlocks[i];
+        if (
+          block.listData?.listStyle === "ordered" &&
+          block.listData?.depth === props.listData.depth
+        ) {
+          const currentNumber = block.listData.listNumber || 1;
+          await rep.mutate.assertFact({
+            entity: block.value,
+            attribute: "block/list-number",
+            data: { type: "number", value: currentNumber + difference },
+          });
+        }
+      }
+    }
+
+    setEditingNumber(false);
+  };
   return (
     <div
       className={`shrink-0  flex justify-end items-center h-3 z-1
@@ -456,14 +518,49 @@ export const ListMarker = (
         }}
         className={`listMarker group/list-marker p-2 ${children.length > 0 ? "cursor-pointer" : "cursor-default"}`}
       >
-        <div
-          className={`h-[5px] w-[5px] rounded-full bg-secondary shrink-0 right-0 outline  outline-offset-1
-                      ${
-                        folded
-                          ? "outline-secondary"
-                          : ` ${children.length > 0 ? "sm:group-hover/list-marker:outline-secondary outline-transparent" : "outline-transparent"}`
-                      }`}
-        />
+        {listStyle?.data.value === "ordered" ? (
+          editingNumber ? (
+            <input
+              type="text"
+              value={numberInputValue}
+              onChange={(e) => setNumberInputValue(e.target.value)}
+              onClick={(e) => e.stopPropagation()}
+              onBlur={handleNumberSave}
+              onKeyDown={(e) => {
+                if (e.key === "Enter") {
+                  e.preventDefault();
+                  handleNumberSave();
+                } else if (e.key === "Escape") {
+                  setEditingNumber(false);
+                }
+              }}
+              autoFocus
+              className="text-secondary font-normal text-right min-w-[2rem] w-[2.2rem] bg-transparent border border-accent focus:outline-none px-1"
+            />
+          ) : (
+            <div
+              className="text-secondary font-normal text-right min-w-[2rem] cursor-pointer hover:text-primary"
+              onClick={(e) => {
+                e.stopPropagation();
+                if (permissions.write && listStyle?.data.value === "ordered") {
+                  setNumberInputValue(String(props.listData?.listNumber || 1));
+                  setEditingNumber(true);
+                }
+              }}
+            >
+              {props.listData?.listNumber || 1}.
+            </div>
+          )
+        ) : (
+          <div
+            className={`h-[5px] w-[5px] rounded-full bg-secondary shrink-0 right-0 outline  outline-offset-1
+                        ${
+                          folded
+                            ? "outline-secondary"
+                            : ` ${children.length > 0 ? "sm:group-hover/list-marker:outline-secondary outline-transparent" : "outline-transparent"}`
+                        }`}
+          />
+        )}
       </button>
       {checklist && (
         <button
diff --git a/components/Blocks/BlockCommands.tsx b/components/Blocks/BlockCommands.tsx
index 5e021a47..2f72e7a6 100644
--- a/components/Blocks/BlockCommands.tsx
+++ b/components/Blocks/BlockCommands.tsx
@@ -28,7 +28,7 @@ import {
 } from "components/Icons/BlockTextSmall";
 import { LinkSmall } from "components/Icons/LinkSmall";
 import { BlockRSVPSmall } from "components/Icons/BlockRSVPSmall";
-import { ListUnorderedSmall } from "components/Toolbar/ListToolbar";
+import { ListUnorderedSmall, ListOrderedSmall } from "components/Toolbar/ListToolbar";
 import { BlockMathSmall } from "components/Icons/BlockMathSmall";
 import { BlockCodeSmall } from "components/Icons/BlockCodeSmall";
 import { QuoteSmall } from "components/Icons/QuoteSmall";
@@ -151,7 +151,7 @@ export const blockCommands: Command[] = [
     },
   },
   {
-    name: "List",
+    name: "Unordered List",
     icon: <ListUnorderedSmall />,
     type: "text",
     onSelect: async (rep, props, um) => {
@@ -164,6 +164,32 @@ export const blockCommands: Command[] = [
       clearCommandSearchText(entity);
     },
   },
+  {
+    name: "Ordered List",
+    icon: <ListOrderedSmall />,
+    type: "text",
+    onSelect: async (rep, props, um) => {
+      let entity = await createBlockWithType(rep, props, "text");
+      await rep?.mutate.assertFact([
+        {
+          entity,
+          attribute: "block/is-list",
+          data: { value: true, type: "boolean" },
+        },
+        {
+          entity,
+          attribute: "block/list-style",
+          data: { value: "ordered", type: "list-style-union" },
+        },
+        {
+          entity,
+          attribute: "block/list-number",
+          data: { value: 1, type: "number" },
+        },
+      ]);
+      clearCommandSearchText(entity);
+    },
+  },
   {
     name: "Block Quote",
     icon: <QuoteSmall />,
diff --git a/components/Blocks/MailboxBlock.tsx b/components/Blocks/MailboxBlock.tsx
index 1bc591cd..48ae280e 100644
--- a/components/Blocks/MailboxBlock.tsx
+++ b/components/Blocks/MailboxBlock.tsx
@@ -13,7 +13,7 @@ import { confirmEmailSubscription } from "actions/subscriptions/confirmEmailSubs
 import { focusPage } from "src/utils/focusPage";
 import { v7 } from "uuid";
 import { sendPostToSubscribers } from "actions/subscriptions/sendPostToSubscribers";
-import { getBlocksWithType } from "src/hooks/queries/useBlocks";
+import { getBlocksWithType } from "src/replicache/getBlocks";
 import { getBlocksAsHTML } from "src/utils/getBlocksAsHTML";
 import { htmlToMarkdown } from "src/htmlMarkdownParsers";
 import {
diff --git a/components/Blocks/TextBlock/inputRules.ts b/components/Blocks/TextBlock/inputRules.ts
index f20e9465..5c38b718 100644
--- a/components/Blocks/TextBlock/inputRules.ts
+++ b/components/Blocks/TextBlock/inputRules.ts
@@ -154,11 +154,44 @@ export const inputrules = (
         if (propsRef.current.listData) return null;
         let tr = state.tr;
         tr.delete(0, 2);
-        repRef.current?.mutate.assertFact({
-          entity: propsRef.current.entityID,
-          attribute: "block/is-list",
-          data: { type: "boolean", value: true },
-        });
+        repRef.current?.mutate.assertFact([
+          {
+            entity: propsRef.current.entityID,
+            attribute: "block/is-list",
+            data: { type: "boolean", value: true },
+          },
+          {
+            entity: propsRef.current.entityID,
+            attribute: "block/list-style",
+            data: { type: "list-style-union", value: "unordered" },
+          },
+        ]);
+        return tr;
+      }),
+
+      // Ordered List - respect the starting number typed
+      new InputRule(/^(\d+)\.\s$/, (state, match) => {
+        if (propsRef.current.listData) return null;
+        let tr = state.tr;
+        tr.delete(0, match[0].length);
+        const startNumber = parseInt(match[1], 10);
+        repRef.current?.mutate.assertFact([
+          {
+            entity: propsRef.current.entityID,
+            attribute: "block/is-list",
+            data: { type: "boolean", value: true },
+          },
+          {
+            entity: propsRef.current.entityID,
+            attribute: "block/list-style",
+            data: { type: "list-style-union", value: "ordered" },
+          },
+          {
+            entity: propsRef.current.entityID,
+            attribute: "block/list-number",
+            data: { type: "number", value: startNumber },
+          },
+        ]);
         return tr;
       }),
 
diff --git a/components/Blocks/TextBlock/keymap.ts b/components/Blocks/TextBlock/keymap.ts
index 1012c137..07081388 100644
--- a/components/Blocks/TextBlock/keymap.ts
+++ b/components/Blocks/TextBlock/keymap.ts
@@ -21,7 +21,7 @@ import { focusPage } from "src/utils/focusPage";
 import { v7 } from "uuid";
 import { scanIndex } from "src/replicache/utils";
 import { indent, outdent } from "src/utils/list-operations";
-import { getBlocksWithType } from "src/hooks/queries/useBlocks";
+import { getBlocksWithType } from "src/replicache/getBlocks";
 import { isTextBlock } from "src/utils/isTextBlock";
 import { UndoManager } from "src/undoManager";
 type PropsRef = RefObject<
@@ -369,11 +369,15 @@ const shifttab =
     propsRef: RefObject<BlockProps & { entity_set: { set: string } }>,
     repRef: RefObject<Replicache<ReplicacheMutators> | null>,
   ) =>
-  () => {
+  async () => {
     if (useUIState.getState().selectedBlocks.length > 1) return false;
     if (!repRef.current) return false;
     if (!repRef.current) return false;
-    outdent(propsRef.current, propsRef.current.previousBlock, repRef.current);
+    let { foldedBlocks, toggleFold } = useUIState.getState();
+    await outdent(propsRef.current, propsRef.current.previousBlock, repRef.current, {
+      foldedBlocks,
+      toggleFold,
+    });
     return true;
   };
 
@@ -423,12 +427,40 @@ const enter =
             y: position.data.position.y + box.height,
           },
         });
-        if (propsRef.current.listData)
+        if (propsRef.current.listData) {
           await repRef.current?.mutate.assertFact({
             entity: newEntityID,
             attribute: "block/is-list",
             data: { type: "boolean", value: true },
           });
+          // Copy list style for canvas blocks
+          let listStyle = await repRef.current?.query((tx) =>
+            scanIndex(tx).eav(propsRef.current.entityID, "block/list-style"),
+          );
+          if (listStyle?.[0])
+            await repRef.current?.mutate.assertFact({
+              entity: newEntityID,
+              attribute: "block/list-style",
+              data: {
+                type: "list-style-union",
+                value: listStyle[0].data.value,
+              },
+            });
+          // Set list number to next number if this is an ordered list
+          if (listStyle?.[0]) {
+            let listNumber = await repRef.current?.query((tx) =>
+              scanIndex(tx).eav(propsRef.current.entityID, "block/list-number"),
+            );
+            await repRef.current?.mutate.assertFact({
+              entity: newEntityID,
+              attribute: "block/list-number",
+              data: {
+                type: "number",
+                value: (listNumber?.[0]?.data.value || 0) + 1,
+              },
+            });
+          }
+        }
         return;
       }
       if (propsRef.current.listData) {
@@ -499,6 +531,33 @@ const enter =
           attribute: "block/is-list",
           data: { type: "boolean", value: true },
         });
+        // Copy list style (ordered/unordered) to new list item
+        let listStyle = await repRef.current?.query((tx) =>
+          scanIndex(tx).eav(propsRef.current.entityID, "block/list-style"),
+        );
+        if (listStyle?.[0])
+          await repRef.current?.mutate.assertFact({
+            entity: newEntityID,
+            attribute: "block/list-style",
+            data: {
+              type: "list-style-union",
+              value: listStyle[0].data.value,
+            },
+          });
+        // Set list number to next number if this is an ordered list
+        if (listStyle?.[0]) {
+          let listNumber = await repRef.current?.query((tx) =>
+            scanIndex(tx).eav(propsRef.current.entityID, "block/list-number"),
+          );
+          await repRef.current?.mutate.assertFact({
+            entity: newEntityID,
+            attribute: "block/list-number",
+            data: {
+              type: "number",
+              value: (listNumber?.[0]?.data.value || 0) + 1,
+            },
+          });
+        }
         let checked = await repRef.current?.query((tx) =>
           scanIndex(tx).eav(propsRef.current.entityID, "block/check-list"),
         );
diff --git a/components/Blocks/useBlockKeyboardHandlers.ts b/components/Blocks/useBlockKeyboardHandlers.ts
index 18b1f43b..0b2a8793 100644
--- a/components/Blocks/useBlockKeyboardHandlers.ts
+++ b/components/Blocks/useBlockKeyboardHandlers.ts
@@ -91,15 +91,16 @@ type Args = {
 
 const AllowedIfTextBlock = ["Tab"];
 
-function Tab({ e, props, rep }: Args) {
+async function Tab({ e, props, rep }: Args) {
   // if tab or shift tab, indent or outdent
   if (useUIState.getState().selectedBlocks.length > 1) return false;
+  let { foldedBlocks, toggleFold } = useUIState.getState();
   if (e.shiftKey) {
     e.preventDefault();
-    outdent(props, props.previousBlock, rep);
+    await outdent(props, props.previousBlock, rep, { foldedBlocks, toggleFold });
   } else {
     e.preventDefault();
-    if (props.previousBlock) indent(props, props.previousBlock, rep);
+    if (props.previousBlock) indent(props, props.previousBlock, rep, { foldedBlocks, toggleFold });
   }
 }
 
diff --git a/components/Blocks/useBlockMouseHandlers.ts b/components/Blocks/useBlockMouseHandlers.ts
index eca3cc68..6f99cf46 100644
--- a/components/Blocks/useBlockMouseHandlers.ts
+++ b/components/Blocks/useBlockMouseHandlers.ts
@@ -5,7 +5,7 @@ import { Block } from "./Block";
 import { isTextBlock } from "src/utils/isTextBlock";
 import { useEntitySetContext } from "components/EntitySetProvider";
 import { useReplicache } from "src/replicache";
-import { getBlocksWithType } from "src/hooks/queries/useBlocks";
+import { getBlocksWithType } from "src/replicache/getBlocks";
 import { focusBlock } from "src/utils/focusBlock";
 import { useIsMobile } from "src/hooks/isMobile";
 import { scrollIntoViewIfNeeded } from "src/utils/scrollIntoViewIfNeeded";
diff --git a/components/SelectionManager/index.tsx b/components/SelectionManager/index.tsx
index c822ac0a..81411ac0 100644
--- a/components/SelectionManager/index.tsx
+++ b/components/SelectionManager/index.tsx
@@ -6,7 +6,7 @@ import { scanIndex } from "src/replicache/utils";
 import { focusBlock } from "src/utils/focusBlock";
 import { useEditorStates } from "src/state/useEditorState";
 import { useEntitySetContext } from "../EntitySetProvider";
-import { getBlocksWithType } from "src/hooks/queries/useBlocks";
+import { getBlocksWithType } from "src/replicache/getBlocks";
 import { indent, outdent, outdentFull } from "src/utils/list-operations";
 import { addShortcut, Shortcut } from "src/shortcuts";
 import { elementId } from "src/utils/elementId";
@@ -567,7 +567,8 @@ export function SelectionManager() {
                 previousBlock = siblings[i - parentoffset];
               }
               if (!block.listData || !previousBlock.listData) continue;
-              outdent(block, previousBlock, rep);
+              let { foldedBlocks, toggleFold } = useUIState.getState();
+              await outdent(block, previousBlock, rep, { foldedBlocks, toggleFold });
             }
           } else {
             for (let i = 0; i < siblings.length; i++) {
@@ -588,7 +589,8 @@ export function SelectionManager() {
                 previousBlock = siblings[i - parentoffset];
               }
               if (!block.listData || !previousBlock.listData) continue;
-              indent(block, previousBlock, rep);
+              let { foldedBlocks, toggleFold } = useUIState.getState();
+              indent(block, previousBlock, rep, { foldedBlocks, toggleFold });
             }
           }
         }
diff --git a/components/SelectionManager/selectionState.ts b/components/SelectionManager/selectionState.ts
index 7f45ca43..1e929984 100644
--- a/components/SelectionManager/selectionState.ts
+++ b/components/SelectionManager/selectionState.ts
@@ -2,7 +2,7 @@ import { create } from "zustand";
 import { Replicache } from "replicache";
 import { ReplicacheMutators } from "src/replicache";
 import { useUIState } from "src/useUIState";
-import { getBlocksWithType } from "src/hooks/queries/useBlocks";
+import { getBlocksWithType } from "src/replicache/getBlocks";
 
 export const useSelectingMouse = create(() => ({
   start: null as null | string,
diff --git a/components/Toolbar/ListToolbar.tsx b/components/Toolbar/ListToolbar.tsx
index 14a1d9cd..cdeb4cee 100644
--- a/components/Toolbar/ListToolbar.tsx
+++ b/components/Toolbar/ListToolbar.tsx
@@ -4,7 +4,7 @@ import { useEntity, useReplicache } from "src/replicache";
 import { useUIState } from "src/useUIState";
 import { metaKey } from "src/utils/metaKey";
 import { ToolbarButton } from ".";
-import { indent, outdent, outdentFull } from "src/utils/list-operations";
+import { indent, outdent, outdentFull, orderListItems, unorderListItems } from "src/utils/list-operations";
 import { useEffect } from "react";
 import { Props } from "components/Icons/Props";
 import { ArrowRightTiny } from "components/Icons/ArrowRightTiny";
@@ -70,6 +70,8 @@ export const ListButton = (props: { setToolbarState: (s: "list") => void }) => {
 
 export const ListToolbar = (props: { onClose: () => void }) => {
   let focusedBlock = useUIState((s) => s.focusedEntity);
+  let foldedBlocks = useUIState((s) => s.foldedBlocks);
+  let toggleFold = useUIState((s) => s.toggleFold);
   let siblings = useBlocks(
     focusedBlock?.entityType === "block" ? focusedBlock.parent : null,
   );
@@ -104,9 +106,9 @@ export const ListToolbar = (props: { onClose: () => void }) => {
             </div>
           </div>
         }
-        onClick={() => {
+        onClick={async () => {
           if (!rep || !block) return;
-          outdent(block, previousBlock, rep);
+          await outdent(block, previousBlock, rep, { foldedBlocks, toggleFold });
         }}
       >
         <ListIndentDecreaseSmall />
@@ -126,12 +128,33 @@ export const ListToolbar = (props: { onClose: () => void }) => {
         }
         onClick={() => {
           if (!rep || !block || !previousBlock) return;
-          indent(block, previousBlock, rep);
+          indent(block, previousBlock, rep, { foldedBlocks, toggleFold });
         }}
       >
         <ListIndentIncreaseSmall />
       </ToolbarButton>
       <Separator classname="h-6!" />
+      <ToolbarButton
+        disabled={!isList?.data.value}
+        tooltipContent="Unordered List"
+        onClick={() => {
+          if (!block || !rep) return;
+          unorderListItems(block, rep);
+        }}
+      >
+        <ListUnorderedSmall />
+      </ToolbarButton>
+      <ToolbarButton
+        disabled={!isList?.data.value}
+        tooltipContent="Ordered List"
+        onClick={() => {
+          if (!block || !rep) return;
+          orderListItems(block, rep);
+        }}
+      >
+        <ListOrderedSmall />
+      </ToolbarButton>
+      <Separator classname="h-6" />
       <ToolbarButton
         disabled={!isList?.data.value}
         tooltipContent=<div className="flex flex-col gap-1 justify-center">
@@ -183,6 +206,58 @@ export const ListUnorderedSmall = (props: Props) => {
   );
 };
 
+export const ListOrderedSmall = (props: Props) => {
+  return (
+    <svg
+      width="24"
+      height="24"
+      viewBox="0 0 24 24"
+      fill="none"
+      xmlns="http://www.w3.org/2000/svg"
+      {...props}
+    >
+      {/* Horizontal lines */}
+      <path
+        d="M9 6H20M9 12H20M9 18H20"
+        stroke="currentColor"
+        strokeWidth="1.5"
+        strokeLinecap="round"
+      />
+      {/* Numbers 1, 2, 3 */}
+      <text
+        x="4.5"
+        y="7.5"
+        fontSize="7"
+        fill="currentColor"
+        fontFamily="system-ui, -apple-system, sans-serif"
+        textAnchor="middle"
+      >
+        1.
+      </text>
+      <text
+        x="4.5"
+        y="13.5"
+        fontSize="7"
+        fill="currentColor"
+        fontFamily="system-ui, -apple-system, sans-serif"
+        textAnchor="middle"
+      >
+        2.
+      </text>
+      <text
+        x="4.5"
+        y="19.5"
+        fontSize="7"
+        fill="currentColor"
+        fontFamily="system-ui, -apple-system, sans-serif"
+        textAnchor="middle"
+      >
+        3.
+      </text>
+    </svg>
+  );
+};
+
 const ListIndentIncreaseSmall = (props: Props) => {
   return (
     <svg
diff --git a/components/Toolbar/MultiSelectToolbar.tsx b/components/Toolbar/MultiSelectToolbar.tsx
index c2cbb167..646adcba 100644
--- a/components/Toolbar/MultiSelectToolbar.tsx
+++ b/components/Toolbar/MultiSelectToolbar.tsx
@@ -3,7 +3,7 @@ import { ReplicacheMutators, useReplicache } from "src/replicache";
 import { ToolbarButton } from "./index";
 import { copySelection } from "src/utils/copySelection";
 import { useSmoker } from "components/Toast";
-import { getBlocksWithType } from "src/hooks/queries/useBlocks";
+import { getBlocksWithType } from "src/replicache/getBlocks";
 import { Replicache } from "replicache";
 import { LockBlockButton } from "./LockBlockButton";
 import { Props } from "components/Icons/Props";
diff --git a/src/hooks/queries/useBlocks.ts b/src/hooks/queries/useBlocks.ts
index 78354507..3bd4950f 100644
--- a/src/hooks/queries/useBlocks.ts
+++ b/src/hooks/queries/useBlocks.ts
@@ -1,9 +1,8 @@
-import { Block } from "components/Blocks/Block";
 import { useMemo } from "react";
-import { ReadTransaction } from "replicache";
 import { useSubscribe } from "src/replicache/useSubscribe";
-import { Fact, useReplicache } from "src/replicache";
+import { useReplicache } from "src/replicache";
 import { scanIndex, scanIndexLocal } from "src/replicache/utils";
+import { getBlocksWithType, getBlocksWithTypeLocal } from "src/replicache/getBlocks";
 
 export const useBlocks = (entityID: string | null) => {
   let rep = useReplicache();
@@ -69,134 +68,3 @@ export const useCanvasBlocksWithType = (entityID: string | null) => {
     });
 };
 
-export const getBlocksWithType = async (
-  tx: ReadTransaction,
-  entityID: string,
-) => {
-  let initialized = await tx.get("initialized");
-  if (!initialized) return null;
-  let scan = scanIndex(tx);
-  let blocks = await scan.eav(entityID, "card/block");
-
-  return (
-    await Promise.all(
-      blocks
-        .sort((a, b) => {
-          if (a.data.position === b.data.position) return a.id > b.id ? 1 : -1;
-          return a.data.position > b.data.position ? 1 : -1;
-        })
-        .map(async (b) => {
-          let type = (await scan.eav(b.data.value, "block/type"))[0];
-          let isList = await scan.eav(b.data.value, "block/is-list");
-          if (!type) return null;
-          if (isList[0]?.data.value) {
-            const getChildren = async (
-              root: Fact<"card/block">,
-              parent: string,
-              depth: number,
-              path: { depth: number; entity: string }[],
-            ): Promise<Block[]> => {
-              let children = (
-                await scan.eav(root.data.value, "card/block")
-              ).sort((a, b) => (a.data.position > b.data.position ? 1 : -1));
-              let type = (await scan.eav(root.data.value, "block/type"))[0];
-              let checklist = await scan.eav(
-                root.data.value,
-                "block/check-list",
-              );
-              if (!type) return [];
-              let newPath = [...path, { entity: root.data.value, depth }];
-              let childBlocks = await Promise.all(
-                children.map((c) =>
-                  getChildren(c, root.data.value, depth + 1, newPath),
-                ),
-              );
-              return [
-                {
-                  ...root.data,
-                  factID: root.id,
-                  type: type.data.value,
-                  parent: b.entity,
-                  listData: {
-                    depth: depth,
-                    parent,
-                    path: newPath,
-                    checklist: !!checklist[0],
-                  },
-                },
-                ...childBlocks.flat(),
-              ];
-            };
-            return getChildren(b, b.entity, 1, []);
-          }
-          return [
-            {
-              ...b.data,
-              factID: b.id,
-              type: type.data.value,
-              parent: b.entity,
-            },
-          ] as Block[];
-        }),
-    )
-  )
-    .flat()
-    .filter((f) => f !== null);
-};
-
-export const getBlocksWithTypeLocal = (
-  initialFacts: Fact<any>[],
-  entityID: string,
-) => {
-  let scan = scanIndexLocal(initialFacts);
-  let blocks = scan.eav(entityID, "card/block");
-  return blocks
-    .sort((a, b) => {
-      if (a.data.position === b.data.position) return a.id > b.id ? 1 : -1;
-      return a.data.position > b.data.position ? 1 : -1;
-    })
-    .map((b) => {
-      let type = scan.eav(b.data.value, "block/type")[0];
-      let isList = scan.eav(b.data.value, "block/is-list");
-      if (!type) return null;
-      if (isList[0]?.data.value) {
-        const getChildren = (
-          root: Fact<"card/block">,
-          parent: string,
-          depth: number,
-          path: { depth: number; entity: string }[],
-        ): Block[] => {
-          let children = scan
-            .eav(root.data.value, "card/block")
-            .sort((a, b) => (a.data.position > b.data.position ? 1 : -1));
-          let type = scan.eav(root.data.value, "block/type")[0];
-          if (!type) return [];
-          let newPath = [...path, { entity: root.data.value, depth }];
-          let childBlocks = children.map((c) =>
-            getChildren(c, root.data.value, depth + 1, newPath),
-          );
-          return [
-            {
-              ...root.data,
-              factID: root.id,
-              type: type.data.value,
-              parent: b.entity,
-              listData: { depth: depth, parent, path: newPath },
-            },
-            ...childBlocks.flat(),
-          ];
-        };
-        return getChildren(b, b.entity, 1, []);
-      }
-      return [
-        {
-          ...b.data,
-          factID: b.id,
-          type: type.data.value,
-          parent: b.entity,
-        },
-      ] as Block[];
-    })
-    .flat()
-    .filter((f) => f !== null);
-};
diff --git a/src/replicache/attributes.ts b/src/replicache/attributes.ts
index 4f00e8e9..3d69681c 100644
--- a/src/replicache/attributes.ts
+++ b/src/replicache/attributes.ts
@@ -99,6 +99,14 @@ const BlockAttributes = {
     type: "string",
     cardinality: "one",
   },
+  "block/list-style": {
+    type: "list-style-union",
+    cardinality: "one",
+  },
+  "block/list-number": {
+    type: "number",
+    cardinality: "one",
+  },
 } as const;
 
 const MailboxAttributes = {
@@ -355,6 +363,10 @@ export type Data<A extends keyof typeof Attributes> = {
     type: "canvas-pattern-union";
     value: "dot" | "grid" | "plain";
   };
+  "list-style-union": {
+    type: "list-style-union";
+    value: "ordered" | "unordered";
+  };
   color: { type: "color"; value: string };
 }[(typeof Attributes)[A]["type"]];
 export type FilterAttributes<F extends Partial<Attributes[keyof Attributes]>> =
diff --git a/src/replicache/getBlocks.ts b/src/replicache/getBlocks.ts
new file mode 100644
index 00000000..baf92fa1
--- /dev/null
+++ b/src/replicache/getBlocks.ts
@@ -0,0 +1,150 @@
+import { Block } from "components/Blocks/Block";
+import { ReadTransaction } from "replicache";
+import { Fact } from "src/replicache";
+import { scanIndex, scanIndexLocal } from "src/replicache/utils";
+
+export const getBlocksWithType = async (
+  tx: ReadTransaction,
+  entityID: string,
+) => {
+  let initialized = await tx.get("initialized");
+  if (!initialized) return null;
+  let scan = scanIndex(tx);
+  let blocks = await scan.eav(entityID, "card/block");
+
+  return (
+    await Promise.all(
+      blocks
+        .sort((a, b) => {
+          if (a.data.position === b.data.position) return a.id > b.id ? 1 : -1;
+          return a.data.position > b.data.position ? 1 : -1;
+        })
+        .map(async (b) => {
+          let type = (await scan.eav(b.data.value, "block/type"))[0];
+          let isList = await scan.eav(b.data.value, "block/is-list");
+          if (!type) return null;
+          // All lists use recursive structure
+          if (isList[0]?.data.value) {
+            const getChildren = async (
+              root: Fact<"card/block">,
+              parent: string,
+              depth: number,
+              path: { depth: number; entity: string }[],
+            ): Promise<Block[]> => {
+              let children = (
+                await scan.eav(root.data.value, "card/block")
+              ).sort((a, b) => (a.data.position > b.data.position ? 1 : -1));
+              let type = (await scan.eav(root.data.value, "block/type"))[0];
+              let checklist = await scan.eav(
+                root.data.value,
+                "block/check-list",
+              );
+              let listStyle = (await scan.eav(root.data.value, "block/list-style"))[0];
+              let listNumber = (await scan.eav(root.data.value, "block/list-number"))[0];
+              if (!type) return [];
+              let newPath = [...path, { entity: root.data.value, depth }];
+              let childBlocks = await Promise.all(
+                children.map((c) =>
+                  getChildren(c, root.data.value, depth + 1, newPath),
+                ),
+              );
+              return [
+                {
+                  ...root.data,
+                  factID: root.id,
+                  type: type.data.value,
+                  parent: b.entity,
+                  listData: {
+                    depth: depth,
+                    parent,
+                    path: newPath,
+                    checklist: !!checklist[0],
+                    listStyle: listStyle?.data.value,
+                    listNumber: listNumber?.data.value,
+                  },
+                },
+                ...childBlocks.flat(),
+              ];
+            };
+            return getChildren(b, b.entity, 1, []);
+          }
+          return [
+            {
+              ...b.data,
+              factID: b.id,
+              type: type.data.value,
+              parent: b.entity,
+            },
+          ] as Block[];
+        }),
+    )
+  )
+    .flat()
+    .filter((f) => f !== null);
+};
+
+export const getBlocksWithTypeLocal = (
+  initialFacts: Fact<any>[],
+  entityID: string,
+) => {
+  let scan = scanIndexLocal(initialFacts);
+  let blocks = scan.eav(entityID, "card/block");
+  return blocks
+    .sort((a, b) => {
+      if (a.data.position === b.data.position) return a.id > b.id ? 1 : -1;
+      return a.data.position > b.data.position ? 1 : -1;
+    })
+    .map((b) => {
+      let type = scan.eav(b.data.value, "block/type")[0];
+      let isList = scan.eav(b.data.value, "block/is-list");
+      if (!type) return null;
+      // All lists use recursive structure
+      if (isList[0]?.data.value) {
+        const getChildren = (
+          root: Fact<"card/block">,
+          parent: string,
+          depth: number,
+          path: { depth: number; entity: string }[],
+        ): Block[] => {
+          let children = scan
+            .eav(root.data.value, "card/block")
+            .sort((a, b) => (a.data.position > b.data.position ? 1 : -1));
+          let type = scan.eav(root.data.value, "block/type")[0];
+          let listStyle = scan.eav(root.data.value, "block/list-style")[0];
+          let listNumber = scan.eav(root.data.value, "block/list-number")[0];
+          if (!type) return [];
+          let newPath = [...path, { entity: root.data.value, depth }];
+          let childBlocks = children.map((c) =>
+            getChildren(c, root.data.value, depth + 1, newPath),
+          );
+          return [
+            {
+              ...root.data,
+              factID: root.id,
+              type: type.data.value,
+              parent: b.entity,
+              listData: {
+                depth: depth,
+                parent,
+                path: newPath,
+                listStyle: listStyle?.data.value,
+                listNumber: listNumber?.data.value,
+              },
+            },
+            ...childBlocks.flat(),
+          ];
+        };
+        return getChildren(b, b.entity, 1, []);
+      }
+      return [
+        {
+          ...b.data,
+          factID: b.id,
+          type: type.data.value,
+          parent: b.entity,
+        },
+      ] as Block[];
+    })
+    .flat()
+    .filter((f) => f !== null);
+};
diff --git a/src/utils/deleteBlock.ts b/src/utils/deleteBlock.ts
index 50eb3b32..35e8056e 100644
--- a/src/utils/deleteBlock.ts
+++ b/src/utils/deleteBlock.ts
@@ -2,7 +2,7 @@ import { Replicache } from "replicache";
 import { ReplicacheMutators } from "src/replicache";
 import { useUIState } from "src/useUIState";
 import { scanIndex } from "src/replicache/utils";
-import { getBlocksWithType } from "src/hooks/queries/useBlocks";
+import { getBlocksWithType } from "src/replicache/getBlocks";
 import { focusBlock } from "src/utils/focusBlock";
 
 export async function deleteBlock(
diff --git a/src/utils/getBlocksAsHTML.tsx b/src/utils/getBlocksAsHTML.tsx
index 98bf380a..86b68ba5 100644
--- a/src/utils/getBlocksAsHTML.tsx
+++ b/src/utils/getBlocksAsHTML.tsx
@@ -16,15 +16,19 @@ export async function getBlocksAsHTML(
     let parsed = parseBlocksToList(selectedBlocks);
     for (let pb of parsed) {
       if (pb.type === "block") result.push(await renderBlock(pb.block, tx));
-      else
+      else {
+        // Check if the first child is an ordered list
+        let isOrdered = pb.children[0]?.block.listData?.listStyle === "ordered";
+        let tag = isOrdered ? "ol" : "ul";
         result.push(
-          `<ul>${(
+          `<${tag}>${(
             await Promise.all(
               pb.children.map(async (c) => await renderList(c, tx)),
             )
           ).join("\n")}
-          </ul>`,
+          </${tag}>`,
         );
+      }
     }
     return result;
   });
@@ -36,10 +40,15 @@ async function renderList(l: List, tx: ReadTransaction): Promise<string> {
     await Promise.all(l.children.map(async (c) => await renderList(c, tx)))
   ).join("\n");
   let [checked] = await scanIndex(tx).eav(l.block.value, "block/check-list");
+
+  // Check if nested children are ordered or unordered
+  let isOrdered = l.children[0]?.block.listData?.listStyle === "ordered";
+  let tag = isOrdered ? "ol" : "ul";
+
   return `<li ${checked ? `data-checked=${checked.data.value}` : ""}>${await renderBlock(l.block, tx)} ${
     l.children.length > 0
       ? `
-  <ul>${children}</ul>
+  <${tag}>${children}</${tag}>
   `
       : ""
   }</li>`;
diff --git a/src/utils/list-operations.ts b/src/utils/list-operations.ts
index 7ceff234..e0a01ad3 100644
--- a/src/utils/list-operations.ts
+++ b/src/utils/list-operations.ts
@@ -1,27 +1,67 @@
 import { Block } from "components/Blocks/Block";
 import { Replicache } from "replicache";
 import type { ReplicacheMutators } from "src/replicache";
-import { useUIState } from "src/useUIState";
 import { v7 } from "uuid";
+import { getBlocksWithType } from "src/replicache/getBlocks";
+
+export function orderListItems(
+  block: Block,
+  rep?: Replicache<ReplicacheMutators> | null,
+) {
+  if (!block.listData) return;
+  rep?.mutate.assertFact({
+    entity: block.value,
+    attribute: "block/list-style",
+    data: { type: "list-style-union", value: "ordered" },
+  });
+}
+
+export function unorderListItems(
+  block: Block,
+  rep?: Replicache<ReplicacheMutators> | null,
+) {
+  if (!block.listData) return;
+  // Remove list-style attribute to convert back to unordered
+  rep?.mutate.retractAttribute({
+    entity: block.value,
+    attribute: "block/list-style",
+  });
+}
 
 export function indent(
   block: Block,
   previousBlock?: Block,
   rep?: Replicache<ReplicacheMutators> | null,
+  foldState?: {
+    foldedBlocks: string[];
+    toggleFold: (entityID: string) => void;
+  },
 ) {
   if (!block.listData) return false;
+
+  // All lists use parent/child structure - move to new parent
   if (!previousBlock?.listData) return false;
   let depth = block.listData.depth;
   let newParent = previousBlock.listData.path.find((f) => f.depth === depth);
   if (!newParent) return false;
-  if (useUIState.getState().foldedBlocks.includes(newParent.entity))
-    useUIState.getState().toggleFold(newParent.entity);
+  if (foldState && foldState.foldedBlocks.includes(newParent.entity))
+    foldState.toggleFold(newParent.entity);
   rep?.mutate.retractFact({ factID: block.factID });
   rep?.mutate.addLastBlock({
     parent: newParent.entity,
     factID: v7(),
     entity: block.value,
   });
+
+  // Reset number to 1 for ordered lists when indenting
+  if (block.listData.listStyle === "ordered") {
+    rep?.mutate.assertFact({
+      entity: block.value,
+      attribute: "block/list-number",
+      data: { type: "number", value: 1 },
+    });
+  }
+
   return true;
 }
 
@@ -38,6 +78,7 @@ export function outdentFull(
     data: { type: "boolean", value: false },
   });
 
+  // All lists use nested structure - need to handle parent/child structure
   // find the next block that is a level 1 list item or not a list item.
   // If there are none or this block is a level 1 list item, we don't need to move anything
 
@@ -61,13 +102,19 @@ export function outdentFull(
   });
 }
 
-export function outdent(
+export async function outdent(
   block: Block,
   previousBlock: Block | null,
   rep?: Replicache<ReplicacheMutators> | null,
+  foldState?: {
+    foldedBlocks: string[];
+    toggleFold: (entityID: string) => void;
+  },
 ) {
   if (!block.listData) return false;
   let listData = block.listData;
+
+  // All lists use parent/child structure - move blocks between parents
   if (listData.depth === 1) {
     rep?.mutate.assertFact({
       entity: block.value,
@@ -94,13 +141,45 @@ export function outdent(
       )?.entity;
     }
     if (!parent) return false;
-    if (useUIState.getState().foldedBlocks.includes(parent))
-      useUIState.getState().toggleFold(parent);
+    if (foldState && foldState.foldedBlocks.includes(parent))
+      foldState.toggleFold(parent);
     rep?.mutate.outdentBlock({
       block: block.value,
       newParent: parent,
       oldParent: listData.parent,
       after,
     });
+
+    // For ordered lists, calculate the next number at the new depth
+    if (listData.listStyle === "ordered") {
+      let targetDepth = listData.depth - 1;
+      let allBlocks = await rep?.query((tx) =>
+        getBlocksWithType(tx, block.parent),
+      );
+      let previousAtDepth: Block | null = null;
+      if (allBlocks) {
+        let currentIndex = allBlocks.findIndex((b) => b.value === block.value);
+        for (let i = currentIndex - 1; i >= 0; i--) {
+          let b = allBlocks[i];
+          if (
+            b.listData?.listStyle === "ordered" &&
+            b.listData?.depth === targetDepth
+          ) {
+            previousAtDepth = b;
+            break;
+          }
+        }
+      }
+
+      let nextNumber = previousAtDepth?.listData?.listNumber
+        ? previousAtDepth.listData.listNumber + 1
+        : 1;
+
+      rep?.mutate.assertFact({
+        entity: block.value,
+        attribute: "block/list-number",
+        data: { type: "number", value: nextNumber },
+      });
+    }
   }
 }