diff --git a/README.md b/README.md
index 63f7e24..44a6e4e 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,12 @@
+<a href="https://roamjs.com/">
+    <img src="https://avatars.githubusercontent.com/u/138642184" alt="RoamJS Logo" title="RoamJS" align="right" height="60" />
+</a>
+
 # SmartBlocks
 
-Create custom and programmable templates from within Roam!
+**Build powerful, dynamic workflows in Roam—like programmable templates that can write, transform, and fetch data from your graph. Automate daily notes, meeting prep, task flows, and repeatable processes with a rich command system.**
+
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/RoamJS/smartblocks)
 
 ## Overview
 
@@ -30,10 +36,6 @@ The following steps dive into all the features SmartBlocks has to offer in incre
 
 <!-- <div style="position: relative; padding-bottom: 66.66666666666666%; height: 0;"><iframe src="https://www.loom.com/embed/954d916643754027a3889fd5bf7f24dd" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;"></iframe></div> -->
 
-## Migration
-
-This extension was inspired by and acts as version 2 of the original SmartBlocks module in the Roam42 extension. It will soon replace the current SmartBlocks module in Roam42. For a list of all the non-backward compatible changes from V1 to V2, check out the [Migration Guide](https://github.com/RoamJS/smartblocks/blob/main/docs/migration-guide.md).
-
 ## Support
 
 There is an active community at [roamresearch.slack.com](https://join.slack.com/t/roamresearch/shared_invite/zt-ni1vw9yf-HzeWr05ZJBt55j_zfddPsw) in the `#roamjs` channel discussing and building SmartBlocks.
diff --git a/docs/migration-guide.md b/docs/migration-guide.md
deleted file mode 100644
index 83b375c..0000000
--- a/docs/migration-guide.md
+++ /dev/null
@@ -1,159 +0,0 @@
-This page outlines all the changes made from Roam42 to RoamJS SmartBlocks that are not backwards compatible.
-
-# Javascript Executing Commands
-
-The following commands had a role in executing arbitrary JavaScript and will be removed:
-
-- `JAVASCRIPT`
-- `J`
-- `JAVASCRIPTASYNC`
-- `JA`
-- `ONBLOCKEXIT`
-- `IF`
-- `THEN`
-- `ELSE`
-- `IFTRUE`
-
-There are suitable workarounds for most of these commands.
-
-- If you are using a SmartBlock workflow in which you are not the original author of that uses these commands, please reach out to the original author and ask how to migrate
-  - In some cases, the workflow will be updated and available on the [Store]([[smartblocks/smartblocks_store]])
-  - In other cases, the workflow will evolve to becoming its own extension, to be available in Roam's native extension store.
-- If you are the original author of a SmartBlock that uses these commands, please refer to our [Developer Docs](070-developer-docs) for information on how to migrate the logic out of these commands.
-- If you are still unsure of what needs to be done, please reach out to support@roamjs.com or message the support channel on Slack.
-- The first four Javascript commands could be replaced by using the [registerCommand](070-developer-docs#registercommand) API from other extensions or from your personal Roam Graph
-
-# Subcommands
-
-Smartblocks V1 had this notion of "subcommands" - commands that only resolved when paired with a supported command. For example:
-
-- `<%TODOTODAY%> <%PAGE%>`
-
-  Would resolve in a block text that looks like:
-
-- `((block-ref)) [[Name of page with todo block]]`
-
-  This introduced an antipattern of nested command logic residing outside of the commands. In V2, subcommands are now simply formatting options for the output of the parent command. For example, the above should now be written as:
-
-- `<%TODOTODAY:5,(({uid})) {page}%>`
-
-# TODO Commands
-
-Related to the subcommands bullet above, TODO commands used to have the following arguments:
-
-1. Limit
-2. Search terms
-
-They now have the following arguments:
-
-1. Limit
-2. Format
-3. Search terms
-
-# BLOCKMENTIONS Commands
-
-Related to the subcommands bullet above, BLOCKMENTIONS commands now have a formatting argument before the search terms.
-
-# Date Formats
-
-The underlying date formatting library was switched to start using [date-fns](https://date-fns.org/). This means format parameters for `DATE` commands will be using different conventions. Please consult the [formatting docs](https://date-fns.org/v2.23.0/docs/format) to see how to achieve desired behavior.
-
-# JavaScript Commands Return Values
-
-For both async and regular JavaScript commands, you could return any of the following types and it will be handled by the SmartBlocks engine.
-
-- A string - will output the value to a single block
-- An array of strings - will output the value to multiple sibling blocks
-- An array of Nodes - will output the value to multiple sibling and child blocks
-  - A Node is an object with a `text` field of type `string` and a `children` field which maps to an array of Nodes.
-
-# RESOLVEBLOCKREFATEND Removed
-
-Due to [how commands now resolve](020-understanding-commands#command-resolution), `RESOLVEBLOCKREFATEND` is now a redundant command with `RESOLVEBLOCKREF`.
-
-# `REPEAT` Command Changed
-
-The `REPEAT` command now repeats the second argument in the command. So now instead of repeating blocks like this:
-
-- `<%REPEAT:5%>` Repeat Me!
-
-It repeats blocks like this:
-
-- `<%REPEAT:5, Repeat Me!%>`
-
-# `GOTOBLOCK` and `GRAPH` are now parameters.
-
-Related to the sub commands bullet above, the GOTOBLOCK and GRAPH sub commands have been removed in favor of being used as blocks.
-`GOTOBLOCK` should simply be specified as the second argument for its two supported commands, like this:
-
-- `<%OPENPAGE:08-27-2021,GOTOBLOCK 2%>`
-- `<%SIDEBARWINDOWOPEN:08-27-2021,GOTOBLOCK 2%>`
-
-Similarly, `GRAPH` should be specified as the second argument to its one supported command:
-
-- `<%SIDEBARWINDOWOPEN:08-27-2021,GRAPH%>`
-
-Additionally, `GOTOBLOCK` now supports any numerical value, not just 1 or -1.
-
-# `42Setting` Removed
-
-A goal of creating the SmartBlocks extension was so that it could live independently, absent the original Roam42 extension. This means removing any Roam42 specific functionality. This resulted in the removal of the `42Setting` command.
-This command can be replaced using the existing SmartBlocks command set. For example, to replace a block that had this:
-
-- `<%42SETTING:name%>`
-- Can be replaced with this block:
-
-- `<%REPLACE:<%REPLACE:<%RESOLVEBLOCKREF:<%BLOCKMENTIONS:1,42Setting,{uid},name%>%>,<%HASHTAG:42Setting%>%>, name %>`
-
-It will be supported when the SmartBlocks extension is in included with the Roam42 bundle.
-
-# `roam42` methods
-
-If you used `JAVASCRIPT` commands that contain `roam42.common` methods, these methods will no longer be available by default with SmartBlocks v2. Here are a list of common Roam42 methods with their mitigation nested under it:
-
-- `roam42.common.createBlock(parent_uid, order, block_string)`
-
-```javascript
-const uid = window.roamAlphaAPI.util.generateUID();
-window.roamAlphaAPI.createBlock({
-  location: { "parent-uid": parent_uid, order },
-  block: { string: block_string, uid },
-});
-return uid;
-```
-
-- `roam42.common.createSiblingBlock(fromUID, block_string, bBelow)`
-
-```javascript
-const [{ order }, { uid: parent_uid }] = window.roamAlphaAPI.q(`[:find 
-(pull ?b [:block/order]) (pull ?p [:block/uid])
-:where 
-[?b :block/uid "${fromUID}"]
-[?p :block/children ?b]
-]`)[0];
-const uid = window.roamAlphaAPI.util.generateUID();
-window.roamAlphaAPI.createBlock({
-  location: { "parent-uid": parent_uid, order: order + bBelow },
-  block: { string: block_string, uid },
-});
-return uid;
-```
-
-- `roam42.common.moveCursorToNextBlock`
-  - This method is pretty hacky and would not recommend using until Roam releases an API for doing this. In any case, if you're still interested, I would look at [the source code directly](https://github.com/RoamJS/workbench/blob/cd67ed575146dde8695f5eb33974ce0020abf069/legacy/common/commonFunctions.js#L317-L330).
-- `roam42.common.moveCursorToPreviousBlock`
-  - This method is pretty hacky and would not recommend using until Roam releases an API for doing this. In any case, if you're still interested, I would look at [the source code directly](https://github.com/RoamJS/workbench/blob/cd67ed575146dde8695f5eb33974ce0020abf069/legacy/common/commonFunctions.js#L332-L344).
-- `roam42.common.updateBlock(uid, block_string, open)`
-
-```javascript
-window.roamAlphaAPI.updateBlock({
-  block: { uid, string: block_string, open },
-});
-```
-
-- `roam42.settings.get`
-
-  - I would use `SET` and `GET` commands instead. If insistent on using Roam42 Settings, then see [this section](#42setting-removed)
-
-- `roam42.smartBlocks.activeWorkflow.vars[name]`
-  - Smartblock Variables are not available by default in `JAVASCRIPT` commands. Simply use the variable `name`.
diff --git a/package-lock.json b/package-lock.json
index 0a0d849..2767a60 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "smartblocks",
-  "version": "1.12.3",
+  "version": "1.14.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "smartblocks",
-      "version": "1.12.3",
+      "version": "1.14.0",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {
diff --git a/package.json b/package.json
index d0a33be..1c2fc35 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "smartblocks",
-  "version": "1.12.3",
+  "version": "1.14.0",
   "description": "Create custom and programmable templates from within Roam!",
   "main": "./build/main.js",
   "scripts": {
diff --git a/src/HotKeyPanel.tsx b/src/HotKeyPanel.tsx
index 3d69f10..fea02f6 100644
--- a/src/HotKeyPanel.tsx
+++ b/src/HotKeyPanel.tsx
@@ -81,6 +81,7 @@ const HotKeyEntry = ({
           }}
           transformItem={(e) => workflowNamesByUid[e]}
           className={"w-full"}
+          popoverProps={{ portalClassName: "roamjs-hotkey-dropdown" }}
         />
       </Label>
       <Button
diff --git a/src/SmartblocksMenu.tsx b/src/SmartblocksMenu.tsx
index 2c4cb87..ec496c6 100644
--- a/src/SmartblocksMenu.tsx
+++ b/src/SmartblocksMenu.tsx
@@ -108,13 +108,19 @@ const SmartblocksMenu = ({
   const keydownListener = useCallback(
     (e: KeyboardEvent) => {
       if (!menuRef.current) return;
-      if (e.key === "ArrowDown") {
+      const isDown =
+        e.key === "ArrowDown" ||
+        (e.ctrlKey && (e.key === "n" || e.key === "j"));
+      const isUp =
+        e.key === "ArrowUp" ||
+        (e.ctrlKey && (e.key === "p" || e.key === "k"));
+      if (isDown) {
         const index = Number(menuRef.current.getAttribute("data-active-index"));
         const count = menuRef.current.childElementCount;
         setActiveIndex((index + 1) % count);
         e.stopPropagation();
         e.preventDefault();
-      } else if (e.key === "ArrowUp") {
+      } else if (isUp) {
         const index = Number(menuRef.current.getAttribute("data-active-index"));
         const count = menuRef.current.childElementCount;
         setActiveIndex((index - 1 + count) % count);
diff --git a/src/index.ts b/src/index.ts
index 113a35e..673e9e7 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -38,6 +38,7 @@ import XRegExp from "xregexp";
 import { PullBlock } from "roamjs-components/types";
 import getParentUidByBlockUid from "roamjs-components/queries/getParentUidByBlockUid";
 import getShallowTreeByParentUid from "roamjs-components/queries/getShallowTreeByParentUid";
+import getBasicTreeByParentUid from "roamjs-components/queries/getBasicTreeByParentUid";
 import extractRef from "roamjs-components/util/extractRef";
 import getDailyConfig from "./utils/getDailyConfig";
 import saveDailyConfig from "./utils/saveDailyConfig";
@@ -107,6 +108,11 @@ export default runExtension(async ({ extensionAPI }) => {
 .roamjs-smartblock-menu {
   width: 300px;
 }
+
+.roamjs-hotkey-dropdown .bp3-menu {
+  max-height: 300px;
+  overflow-y: auto;
+}
 .rm-settings-tabs .roamjs-daily-config-tabs .bp3-tab-list {
   padding: 2px;
   background: none;
@@ -592,22 +598,96 @@ export default runExtension(async ({ extensionAPI }) => {
     },
   });
 
+  const ROAM_TABLE_REGEX = /\{\{\[\[table\]\]\}\}/i;
+  type TableNode = {
+    uid: string;
+    children?: TableNode[];
+  };
+
+  const getRoamTableUidRows = (nodes: TableNode[] = []): string[][] =>
+    nodes.flatMap((node) => {
+      if (!node?.uid) return [];
+      const children = (node.children || []).filter(
+        (c): c is TableNode => !!c?.uid
+      );
+      if (!children.length) return [[node.uid]];
+      const childRows = getRoamTableUidRows(children);
+      return childRows.length
+        ? childRows.map((row) => [node.uid, ...row])
+        : [[node.uid]];
+    });
+
+  const resolveRoamTableButtonBlock = ({
+    el,
+    tableUid,
+    label,
+  }: {
+    el: HTMLElement;
+    tableUid: string;
+    label: string;
+  }): { uid: string; text: string; occurrenceIndex: number } | null => {
+    const tableEl = el.closest("table");
+    const rowEl = el.closest("tr");
+    const cellEl = el.closest("td");
+    if (!tableEl || !rowEl || !cellEl) return null;
+
+    const tableRows = Array.from(tableEl.querySelectorAll("tr")).filter(
+      (row) => row.querySelectorAll("td").length > 0
+    );
+    const rowIndex = tableRows.indexOf(rowEl);
+    const cells = Array.from(rowEl.querySelectorAll("td"));
+    const columnIndex = cells.indexOf(cellEl);
+    if (rowIndex < 0 || columnIndex < 0) return null;
+
+    const uidRows = getRoamTableUidRows(
+      getBasicTreeByParentUid(tableUid) as unknown as TableNode[]
+    );
+    const uid = uidRows[rowIndex]?.[columnIndex];
+    if (!uid) return null;
+
+    const text = getTextByBlockUid(uid);
+    const sameLabelButtonsInCell = Array.from(
+      cellEl.querySelectorAll("button.bp3-button.bp3-small.dont-focus-block")
+    ).filter((button) => (button.textContent || "").trim() === label);
+    const occurrenceIndex = sameLabelButtonsInCell.indexOf(
+      el as HTMLButtonElement
+    );
+    const safeOccurrenceIndex = occurrenceIndex < 0 ? 0 : occurrenceIndex;
+
+    if (!parseSmartBlockButton(label, text, safeOccurrenceIndex)) return null;
+    return { uid, text, occurrenceIndex: safeOccurrenceIndex };
+  };
+
   const registerElAsSmartBlockTrigger = ({
     textContent,
     text,
     el,
     parentUid,
     hideIcon,
+    occurrenceIndex = 0,
   }: {
     textContent: string;
     text: string;
     el: HTMLElement;
     parentUid: string;
     hideIcon?: boolean;
+    occurrenceIndex?: number;
   }) => {
     // We include textcontent here bc there could be multiple smartblocks in a block
     const label = textContent.trim();
-    const parsed = parseSmartBlockButton(label, text);
+    const tableResolution =
+      ROAM_TABLE_REGEX.test(text) && !!el.closest("table")
+        ? resolveRoamTableButtonBlock({ el, tableUid: parentUid, label })
+        : null;
+    const resolvedParentUid = tableResolution?.uid || parentUid;
+    const resolvedText = tableResolution?.text || text;
+    const resolvedOccurrenceIndex =
+      tableResolution?.occurrenceIndex ?? occurrenceIndex;
+    const parsed = parseSmartBlockButton(
+      label,
+      resolvedText,
+      resolvedOccurrenceIndex
+    );
     if (parsed) {
       const { index, full, buttonContent, workflowName, variables } = parsed;
       const clickListener = () => {
@@ -622,7 +702,7 @@ export default runExtension(async ({ extensionAPI }) => {
               text: "Could not find custom workflow with the name:",
               children: [{ text: workflowName }],
             },
-            parentUid,
+            parentUid: resolvedParentUid,
           });
         } else {
           const keepButton =
@@ -646,29 +726,29 @@ export default runExtension(async ({ extensionAPI }) => {
             mutableCursor: !(
               workflows.find((w) => w.uid === srcUid)?.name || ""
             ).includes("<%NOCURSOR%>"),
-            triggerUid: parentUid,
+            triggerUid: resolvedParentUid,
           };
 
           if (applyToSibling) {
             const sbParentTree = getShallowTreeByParentUid(
-              getParentUidByBlockUid(parentUid)
+              getParentUidByBlockUid(resolvedParentUid)
             );
             const siblingIndex =
-              sbParentTree.findIndex((obj) => obj.uid === parentUid) +
+              sbParentTree.findIndex((obj) => obj.uid === resolvedParentUid) +
               (applyToSibling === "previous" ? -1 : 1);
             const siblingUid = sbParentTree[siblingIndex]?.uid;
             const siblingText = getTextByBlockUid(siblingUid);
 
             updateBlock({
-              uid: parentUid,
+              uid: resolvedParentUid,
               text:
                 clearBlock && keepButton
                   ? full
                   : clearBlock
                   ? ""
                   : keepButton
-                  ? text
-                  : `${text.substring(0, index)}${text.substring(
+                  ? resolvedText
+                  : `${resolvedText.substring(0, index)}${resolvedText.substring(
                       index + full.length
                     )}`,
             });
@@ -687,7 +767,7 @@ export default runExtension(async ({ extensionAPI }) => {
                 )
               : createBlock({
                   node: { text: "" },
-                  parentUid: getParentUidByBlockUid(parentUid),
+                  parentUid: getParentUidByBlockUid(resolvedParentUid),
                   order: siblingIndex === -1 ? 0 : siblingIndex,
                 }).then((targetUid) =>
                   sbBomb({
@@ -712,7 +792,7 @@ export default runExtension(async ({ extensionAPI }) => {
                 })
               : createBlock({
                   node: { text: "" },
-                  parentUid,
+                  parentUid: resolvedParentUid,
                   order,
                 }).then((targetUid) =>
                   sbBomb({
@@ -728,23 +808,23 @@ export default runExtension(async ({ extensionAPI }) => {
                 ),
               clearBlock
                 ? updateBlock({
-                    uid: parentUid,
+                    uid: resolvedParentUid,
                     text: full,
                   })
                 : "";
           } else {
             updateBlock({
-              uid: parentUid,
+              uid: resolvedParentUid,
               text: clearBlock
                 ? ""
-                : `${text.substring(0, index)}${text.substring(
+                : `${resolvedText.substring(0, index)}${resolvedText.substring(
                     index + full.length
                   )}`,
             }).then(() =>
               sbBomb({
                 ...props,
                 target: {
-                  uid: parentUid,
+                  uid: resolvedParentUid,
                   start: index,
                   end: index,
                 },
@@ -806,29 +886,111 @@ export default runExtension(async ({ extensionAPI }) => {
   };
 
   const unloads = new Set<() => void>();
+  // Track button occurrences per block: blockUid -> label -> count
+  const buttonOccurrences = new Map<string, Map<string, number>>();
+  const buttonTextByBlockUid = new Map<string, string>();
+  const buttonGenerationByBlockUid = new Map<string, number>();
+  const buttonCleanupByElement = new Map<HTMLElement, () => void>();
+  const buttonElementsByBlockUid = new Map<string, Set<HTMLElement>>();
+
   const buttonLogoObserver = createHTMLObserver({
     className: "bp3-button bp3-small dont-focus-block",
     tag: "BUTTON",
     callback: (b) => {
       const parentUid = getBlockUidFromTarget(b);
       if (parentUid && !b.hasAttribute("data-roamjs-smartblock-button")) {
+        // Clean up disconnected elements first so stale counts don't break
+        // occurrence tracking during re-renders.
+        const trackedButtons = buttonElementsByBlockUid.get(parentUid);
+        if (trackedButtons) {
+          Array.from(trackedButtons).forEach((el) => {
+            if (!el.isConnected) {
+              buttonCleanupByElement.get(el)?.();
+            }
+          });
+        }
+
         const text = getTextByBlockUid(parentUid);
         b.setAttribute("data-roamjs-smartblock-button", "true");
 
-        // We include textcontent here bc there could be multiple smartblocks in a block
-        // TODO: if multiple smartblocks have the same textContent, we need to distinguish them
+        const cachedText = buttonTextByBlockUid.get(parentUid);
+        if (cachedText !== text) {
+          buttonTextByBlockUid.set(parentUid, text);
+          buttonGenerationByBlockUid.set(
+            parentUid,
+            (buttonGenerationByBlockUid.get(parentUid) || 0) + 1
+          );
+          buttonOccurrences.set(parentUid, new Map());
+        } else if (!buttonOccurrences.has(parentUid)) {
+          buttonOccurrences.set(parentUid, new Map());
+        }
+
+        // Track occurrence index for buttons with the same label in the same block
+        const label = (b.textContent || "").trim();
+        const blockOccurrences = buttonOccurrences.get(parentUid)!;
+        const occurrenceIndex = blockOccurrences.get(label) || 0;
+        blockOccurrences.set(label, occurrenceIndex + 1);
+        const generation = buttonGenerationByBlockUid.get(parentUid) || 0;
+
         const unload = registerElAsSmartBlockTrigger({
           textContent: b.textContent || "",
           text,
           el: b,
           parentUid,
+          occurrenceIndex,
         });
-        unloads.add(() => {
+        const cleanup = () => {
+          if (!buttonCleanupByElement.has(b)) return;
+          buttonCleanupByElement.delete(b);
+          unloads.delete(cleanup);
           b.removeAttribute("data-roamjs-smartblock-button");
           unload();
-        });
+          // Path 1: Remove element from block's button set.
+          // If this was the last button for the block, clear all tracking Maps.
+          const blockButtons = buttonElementsByBlockUid.get(parentUid);
+          if (blockButtons) {
+            blockButtons.delete(b);
+            if (blockButtons.size === 0) {
+              buttonElementsByBlockUid.delete(parentUid);
+              buttonOccurrences.delete(parentUid);
+              buttonTextByBlockUid.delete(parentUid);
+              buttonGenerationByBlockUid.delete(parentUid);
+            }
+          }
+          // Path 2: Decrement per-label occurrence count.
+          // Skip if the block text changed (new generation), since new
+          // buttons will have already reset the occurrence tracking.
+          if ((buttonGenerationByBlockUid.get(parentUid) || 0) !== generation) {
+            return;
+          }
+          const blockOccurrences = buttonOccurrences.get(parentUid);
+          if (blockOccurrences) {
+            const currentCount = blockOccurrences.get(label) || 0;
+            if (currentCount <= 1) {
+              blockOccurrences.delete(label);
+              if (blockOccurrences.size === 0) {
+                buttonOccurrences.delete(parentUid);
+                if (!buttonElementsByBlockUid.get(parentUid)?.size) {
+                  buttonTextByBlockUid.delete(parentUid);
+                  buttonGenerationByBlockUid.delete(parentUid);
+                }
+              }
+            } else {
+              blockOccurrences.set(label, currentCount - 1);
+            }
+          }
+        };
+        const blockButtons =
+          buttonElementsByBlockUid.get(parentUid) || new Set<HTMLElement>();
+        blockButtons.add(b);
+        buttonElementsByBlockUid.set(parentUid, blockButtons);
+        buttonCleanupByElement.set(b, cleanup);
+        unloads.add(cleanup);
       }
     },
+    removeCallback: (b) => {
+      buttonCleanupByElement.get(b)?.();
+    },
   });
 
   const todoObserver = createHTMLObserver({
@@ -959,6 +1121,11 @@ export default runExtension(async ({ extensionAPI }) => {
       unloads.forEach((u) => u());
       window.clearTimeout(getDailyConfig()["next-run-timeout"]);
       saveDailyConfig({ "next-run-timeout": 0 });
+      buttonOccurrences.clear();
+      buttonTextByBlockUid.clear();
+      buttonGenerationByBlockUid.clear();
+      buttonCleanupByElement.clear();
+      buttonElementsByBlockUid.clear();
     },
   };
 });
diff --git a/src/utils/core.ts b/src/utils/core.ts
index 2a7d684..e162351 100644
--- a/src/utils/core.ts
+++ b/src/utils/core.ts
@@ -186,6 +186,83 @@ const getLevelsBelowParentUid = (
   return levels <= 0 || !levels ? tree : getTreeUptoLevel(tree, levels);
 };
 
+const getClipboardIndentUnit = (lines: string[]) => {
+  const spaceIndents = lines
+    .map((line) => line.match(/^[\t ]*/)?.[0] || "")
+    .filter((indent) => !indent.includes("\t"))
+    .map((indent) => indent.length)
+    .filter((length) => length > 0);
+  return spaceIndents.length ? Math.min(...spaceIndents) : 2;
+};
+
+const getClipboardIndentLevel = ({
+  line,
+  indentUnit,
+}: {
+  line: string;
+  indentUnit: number;
+}) => {
+  const indent = line.match(/^[\t ]*/)?.[0] || "";
+  const tabs = (indent.match(/\t/g) || []).length;
+  const spaces = indent.replace(/\t/g, "").length;
+  return tabs + (indentUnit > 0 ? Math.floor(spaces / indentUnit) : 0);
+};
+
+const normalizeClipboardNode = (node: InputTextNode): InputTextNode =>
+  node.children && node.children.length
+    ? { ...node, children: node.children.map(normalizeClipboardNode) }
+    : { ...node, children: undefined };
+
+const parseClipboardSplitText = ({
+  text,
+  noHyphens,
+  noExtraSpaces,
+}: {
+  text: string;
+  noHyphens: boolean;
+  noExtraSpaces: boolean;
+}): InputTextNode[] => {
+  const lines = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+  const meaningful = lines.filter((line) => line.trim().length);
+  const indentUnit = getClipboardIndentUnit(meaningful);
+  const roots: InputTextNode[] = [];
+  const stack: InputTextNode[] = [];
+
+  lines.forEach((line) => {
+    if (!line.trim().length) {
+      roots.push({ text: "" });
+      stack.length = 0;
+      return;
+    }
+
+    const level = getClipboardIndentLevel({ line, indentUnit });
+    const cappedLevel = Math.min(Math.max(level, 0), stack.length);
+    let lineText = line.trimStart();
+    if (noHyphens) {
+      lineText = lineText.replace(/^[-*•]\s+/, "");
+    }
+    if (noExtraSpaces) {
+      lineText = lineText.replace(/\s\s+/g, " ");
+    }
+
+    const node: InputTextNode = { text: lineText, children: [] };
+
+    while (stack.length > cappedLevel) {
+      stack.pop();
+    }
+    if (!stack.length) {
+      roots.push(node);
+    } else {
+      const parent = stack[stack.length - 1];
+      parent.children = parent.children || [];
+      parent.children.push(node);
+    }
+    stack.push(node);
+  });
+
+  return roots.map(normalizeClipboardNode);
+};
+
 addNlpDateParser({
   pattern: () => /D[B,E]O(N)?[M,Y]/i,
   extract: (_, match) => {
@@ -1549,6 +1626,50 @@ export const COMMANDS: {
       return ref;
     },
   },
+  {
+    text: "MOVEBLOCK",
+    help: "Moves a block under a new parent\n\n1. Block ref or uid to move (optional, defaults to current block)\n\n2. Parent ref, uid, or page title (optional, defaults to current parent)\n\n3. Order index or 'last' (optional, defaults to last)",
+    handler: async (blockArg = "", parentArg = "", orderArg = "last") => {
+      const sourceArg = smartBlocksContext.variables[blockArg] || blockArg;
+      const sourceUid =
+        extractRef(sourceArg) || sourceArg || smartBlocksContext.currentUid || "";
+      if (!sourceUid) {
+        return "--> MOVEBLOCK failed: source block was not found <--";
+      }
+
+      const rawParentArg = smartBlocksContext.variables[parentArg] || parentArg;
+      const targetParentUid =
+        getUidFromText(rawParentArg) ||
+        extractRef(rawParentArg) ||
+        rawParentArg ||
+        getParentUidByBlockUid(sourceUid);
+      if (!targetParentUid) {
+        return "--> MOVEBLOCK failed: target parent was not found <--";
+      }
+      if (sourceUid === targetParentUid) {
+        return "--> MOVEBLOCK failed: source block cannot be its own parent <--";
+      }
+
+      const order =
+        /^last$/i.test(orderArg) || !orderArg
+          ? getBasicTreeByParentUid(targetParentUid).length
+          : Math.max(0, Number(orderArg) || 0);
+
+      if (typeof (window.roamAlphaAPI as any).moveBlock !== "function") {
+        return "--> MOVEBLOCK failed: moveBlock API not available <--";
+      }
+      try {
+        await (window.roamAlphaAPI as any).moveBlock({
+          location: { "parent-uid": targetParentUid, order },
+          block: { uid: sourceUid },
+        });
+        return `((${sourceUid}))`;
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        return `--> MOVEBLOCK failed: ${message} <--`;
+      }
+    },
+  },
   {
     text: "INDENT",
     help: "Indents the current block if indentation can be done at current block. ",
@@ -1791,21 +1912,24 @@ export const COMMANDS: {
         .catch((e) => `Failed to paste text: ${e.message}`);
       const postTrim = settings.has("trim") ? raw.trim() : raw;
       const postCarriageOne = settings.has("nocarriagereturn")
-        ? postTrim.replace(/\r\n/g, "")
+        ? postTrim.replace(/\r/g, "")
         : postTrim;
       const postCarriage = settings.has("returnasspace")
         ? postCarriageOne.replace(/(\r)?\n(\r)?/g, " ")
-        : postTrim;
-      const postHyphens = settings.has("nohyphens")
-        ? postCarriage.replace(/- /g, "")
-        : postCarriage;
-      const postSpaces = settings.has("noextraspaces")
-        ? postHyphens.replace(/\s\s+/g, " ")
-        : postHyphens;
-      const postSplit = settings.has("split")
-        ? postSpaces.split(/(?:\r)?\n/)
-        : [postSpaces];
-      return postSplit;
+        : postCarriageOne;
+      if (!settings.has("split")) {
+        const postHyphens = settings.has("nohyphens")
+          ? postCarriage.replace(/- /g, "")
+          : postCarriage;
+        return settings.has("noextraspaces")
+          ? postHyphens.replace(/\s\s+/g, " ")
+          : postHyphens;
+      }
+      return parseClipboardSplitText({
+        text: postCarriage,
+        noHyphens: settings.has("nohyphens"),
+        noExtraSpaces: settings.has("noextraspaces"),
+      });
     },
   },
   {
diff --git a/src/utils/parseSmartBlockButton.ts b/src/utils/parseSmartBlockButton.ts
index c28ac6d..669ba1a 100644
--- a/src/utils/parseSmartBlockButton.ts
+++ b/src/utils/parseSmartBlockButton.ts
@@ -1,6 +1,10 @@
+const escapeRegex = (value: string) =>
+  value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
 export const parseSmartBlockButton = (
   label: string,
-  text: string
+  text: string,
+  occurrenceIndex: number = 0
 ):
   | {
       index: number;
@@ -14,11 +18,22 @@ export const parseSmartBlockButton = (
   const trimmedLabel = label.trim();
   const buttonRegex = trimmedLabel
     ? new RegExp(
-        `{{(${trimmedLabel.replace(/\\+/g, "\\+")}):(?:42)?SmartBlock:(.*?)}}`
+        `{{(${escapeRegex(trimmedLabel)}):(?:42)?SmartBlock:(.*?)}}`,
+        "g"
       )
-    : /{{\s*:(?:42)?SmartBlock:(.*?)}}/;
-  const match = buttonRegex.exec(text);
-  if (!match) return null;
+    : /{{\s*:(?:42)?SmartBlock:(.*?)}}/g;
+
+  // Find all matches
+  const matches = Array.from(text.matchAll(buttonRegex));
+  if (
+    matches.length === 0 ||
+    occurrenceIndex < 0 ||
+    occurrenceIndex >= matches.length
+  ) {
+    return null;
+  }
+
+  const match = matches[occurrenceIndex];
   const index = match.index;
   const full = match[0];
   const buttonContent = trimmedLabel ? match[1] || "" : "";
diff --git a/tests/buttonParsing.test.ts b/tests/buttonParsing.test.ts
index 7336380..c8b199f 100644
--- a/tests/buttonParsing.test.ts
+++ b/tests/buttonParsing.test.ts
@@ -65,3 +65,93 @@ test("parses SmartBlock button for today's entry", () => {
     ButtonContent: "Create Today's Entry",
   });
 });
+
+test("parses multiple labeled SmartBlock buttons in the same block", () => {
+  const text =
+    "{{Run It:SmartBlock:WorkflowOne:RemoveButton=false}} and {{Run It:SmartBlock:WorkflowTwo:Icon=locate,Order=last}}";
+  const first = parseSmartBlockButton("Run It", text, 0);
+  const second = parseSmartBlockButton("Run It", text, 1);
+  expect(first?.workflowName).toBe("WorkflowOne");
+  expect(first?.variables).toMatchObject({
+    RemoveButton: "false",
+    ButtonContent: "Run It",
+  });
+  expect(second?.workflowName).toBe("WorkflowTwo");
+  expect(second?.variables).toMatchObject({
+    Icon: "locate",
+    Order: "last",
+    ButtonContent: "Run It",
+  });
+});
+
+test("parses multiple unlabeled SmartBlock buttons in the same block", () => {
+  const text =
+    "{{:SmartBlock:first:Icon=locate}} and {{:SmartBlock:second:RemoveButton=false}}";
+  const first = parseSmartBlockButton("", text, 0);
+  const second = parseSmartBlockButton("", text, 1);
+  expect(first?.buttonText).toBe("first:Icon=locate");
+  expect(first?.variables).toMatchObject({
+    Icon: "locate",
+    ButtonContent: "",
+  });
+  expect(second?.buttonText).toBe("second:RemoveButton=false");
+  expect(second?.variables).toMatchObject({
+    RemoveButton: "false",
+    ButtonContent: "",
+  });
+});
+
+test("returns null when occurrence index is out of bounds", () => {
+  const text = "{{Only One:SmartBlock:Workflow}}";
+  const result = parseSmartBlockButton("Only One", text, 2);
+  expect(result).toBeNull();
+});
+
+test("returns null when occurrence index is negative", () => {
+  const text = "{{Only One:SmartBlock:Workflow}}";
+  const result = parseSmartBlockButton("Only One", text, -1);
+  expect(result).toBeNull();
+});
+
+test("parses SmartBlock button label containing plus signs", () => {
+  const text = "{{Add+More:SmartBlock:PlusWorkflow}}";
+  const result = parseSmartBlockButton("Add+More", text);
+  expect(result?.workflowName).toBe("PlusWorkflow");
+  expect(result?.variables).toMatchObject({
+    ButtonContent: "Add+More",
+  });
+});
+
+test("parses SmartBlock button label with regex special characters", () => {
+  const text = "{{Add+(Test)[One]?:SmartBlock:WeirdWorkflow}}";
+  const result = parseSmartBlockButton("Add+(Test)[One]?", text);
+  expect(result?.workflowName).toBe("WeirdWorkflow");
+  expect(result?.variables).toMatchObject({
+    ButtonContent: "Add+(Test)[One]?",
+  });
+});
+
+test("returns null for empty text", () => {
+  const result = parseSmartBlockButton("Run", "");
+  expect(result).toBeNull();
+});
+
+test("returns null for empty label with no SmartBlock buttons in text", () => {
+  const result = parseSmartBlockButton("", "just some regular text");
+  expect(result).toBeNull();
+});
+
+test("parses 42SmartBlock variant", () => {
+  const text = "{{Run:42SmartBlock:LegacyWorkflow}}";
+  const result = parseSmartBlockButton("Run", text);
+  expect(result?.workflowName).toBe("LegacyWorkflow");
+});
+
+test("handles label with leading/trailing whitespace", () => {
+  // The function trims the label, but the regex requires an exact match
+  // against the text content after `{{`. Since the text has spaces around
+  // "Run" that don't appear in the trimmed regex pattern, there is no match.
+  const text = "{{  Run  :SmartBlock:TrimWorkflow}}";
+  const result = parseSmartBlockButton("  Run  ", text);
+  expect(result).toBeNull();
+});