diff --git a/package.json b/package.json
index ca043ac..d6a6ee7 100644
--- a/package.json
+++ b/package.json
@@ -11,6 +11,7 @@
   "dependencies": {
     "@flexiformal/ftml": "^0.0.22",
     "@flexiformal/ftml-backend": "^0.0.7",
+    "@flexiformal/ftml-react": "^0.0.25",
     "@mantine/core": "^8.3.10",
     "@mantine/hooks": "^8.3.10",
     "@prisma/adapter-pg": "^7.2.0",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 3a1d55d..858bed6 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -14,6 +14,9 @@ importers:
       '@flexiformal/ftml-backend':
         specifier: ^0.0.7
         version: 0.0.7
+      '@flexiformal/ftml-react':
+        specifier: ^0.0.25
+        version: 0.0.25
       '@mantine/core':
         specifier: ^8.3.10
         version: 8.3.10(@mantine/hooks@8.3.10(react@19.2.3))(@types/react@19.2.7)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
@@ -490,9 +493,15 @@ packages:
   '@flexiformal/ftml-backend@0.0.7':
     resolution: {integrity: sha512-C90rlfSvBzxfwrCbAzDTLmsoNvPi1WVCUEbU+rjPhiaJCFt3bblzTxk7gGFC+iXWrtwyH+KxlOIsxDthbLtcEA==}
 
+  '@flexiformal/ftml-react@0.0.25':
+    resolution: {integrity: sha512-f0eQPmghKW8NF2X8x84NVffQWOpPZOj1pn20IV5hCdI3BpTZns/h+ZiBmkoLls7aC1MU+KdKTQgy4va3GZzQBA==}
+
   '@flexiformal/ftml@0.0.22':
     resolution: {integrity: sha512-DcNc2lrcVHS0kjl1LmjK8sTLNS/TLzR/egKqTIMUYMTuyJmdW2lbtDl8/BCUVT30ktlEgnIUptV7ktVTsQj2vw==}
 
+  '@flexiformal/ftml@0.0.24':
+    resolution: {integrity: sha512-UHzPhub8PDI8ss2jWT4wY9Bryvo0enlpnGGFsQxTgudIN5YtXZH1s1W+dwMlZDydCZj8vwbDZqL0Oys/OIPJMQ==}
+
   '@floating-ui/core@1.7.3':
     resolution: {integrity: sha512-sGnvb5dmrJaKEZ+LDIpguvdX3bDlEllmv4/ClQ9awcmCZrlx5jQyyMWFM5kBI+EyNOCDDiKk8il0zeuX3Zlg/w==}
 
@@ -3403,8 +3412,16 @@ snapshots:
 
   '@flexiformal/ftml-backend@0.0.7': {}
 
+  '@flexiformal/ftml-react@0.0.25':
+    dependencies:
+      '@flexiformal/ftml': 0.0.24
+      react: 19.2.3
+      react-dom: 19.2.3(react@19.2.3)
+
   '@flexiformal/ftml@0.0.22': {}
 
+  '@flexiformal/ftml@0.0.24': {}
+
   '@floating-ui/core@1.7.3':
     dependencies:
       '@floating-ui/utils': 0.2.10
diff --git a/src/components/DuplicateDefinitionDialog.tsx b/src/components/DuplicateDefinitionDialog.tsx
deleted file mode 100644
index 3db7d86..0000000
--- a/src/components/DuplicateDefinitionDialog.tsx
+++ /dev/null
@@ -1,199 +0,0 @@
-import { queryClient } from "@/queryClient";
-import { searchForDuplicateDefinition } from "@/server/ftml/searchForDuplicateDef";
-import { ExtractedItem } from "@/server/text-selection";
-import { updateDefinitionsStatusByIdentity } from "@/serverFns/definitionStatus.server";
-import { FileIdentity } from "@/serverFns/latex.server";
-import {
-  Box,
-  Button,
-  Group,
-  Loader,
-  Modal,
-  Paper,
-  ScrollArea,
-  TextInput,
-} from "@mantine/core";
-import { useState } from "react";
-import { RenderSymbolicUri } from "./RenderUri";
-
-interface Props {
-  opened: boolean;
-  onClose: () => void;
-  extracts: ExtractedItem[];
-  identity: FileIdentity;
-  onConfirm: (duplicates: string[]) => void;
-}
-
-function normalizeUri(uri: string) {
-  try {
-    if (uri.includes("stexmmt.mathhub.info/:sTeX")) {
-      uri = uri.replace("stexmmt.mathhub.info/:sTeX", "https://mathhub.info");
-    }
-    const url = new URL(uri);
-    if (url.protocol !== "https:") url.protocol = "https:";
-    return url.toString();
-  } catch {
-    return uri;
-  }
-}
-
-export function DuplicateDefinitionDialog({
-  opened,
-  onClose,
-  identity,
-}: Props) {
-  const [input, setInput] = useState("");
-  const [search, setSearch] = useState("");
-  const [duplicates, setDuplicates] = useState<string[]>([]);
-
-  const { results, loading } = searchForDuplicateDefinition(search);
-
-  return (
-    <Modal
-      opened={opened}
-      onClose={() => {
-        setDuplicates([]);
-        onClose();
-      }}
-      size="90%"
-      padding="lg"
-      title="Duplicate Definition Check"
-    >
-      <Box
-        style={{
-          height: "75vh",
-          display: "grid",
-          gridTemplateRows: "1fr auto",
-          overflow: "hidden",
-        }}
-      >
-        <Box
-          style={{
-            display: "grid",
-            gridTemplateColumns: "1fr 1fr",
-            gap: 16,
-            minHeight: 0,
-          }}
-        >
-          <Box
-            style={{
-              minHeight: 0,
-              overflow: "hidden",
-            }}
-          >
-          </Box>
-
-          <Box
-            style={{
-              display: "grid",
-              gridTemplateRows: "auto 1fr",
-              minHeight: 0,
-            }}
-          >
-            <Group mb={8}>
-              <TextInput
-                placeholder="Search duplicate definition"
-                value={input}
-                onChange={(e) => setInput(e.currentTarget.value)}
-                style={{ flex: 1 }}
-              />
-              <Button onClick={() => setSearch(input)}>Search</Button>
-            </Group>
-
-            <ScrollArea h="100%" type="auto" scrollbarSize={6}>
-              <Box p="xs">
-                {loading && (
-                  <Group justify="center">
-                    <Loader size="sm" />
-                  </Group>
-                )}
-
-                {results.map((uri) => {
-                  const marked = duplicates.includes(uri);
-
-                  return (
-                    <Paper
-                      key={uri}
-                      withBorder
-                      radius="md"
-                      p={0}
-                      mb="sm"
-                      style={{ overflow: "hidden" }}
-                    >
-                      <Group
-                        justify="space-between"
-                        px="xs"
-                        py={6}
-                        style={{
-                          borderBottom: "1px solid var(--mantine-color-gray-2)",
-                          background: marked
-                            ? "var(--mantine-color-red-0)"
-                            : "var(--mantine-color-gray-0)",
-                        }}
-                      >
-                        <RenderSymbolicUri uri={uri} />
-                        <Button
-                          color="red"
-                          size="xs"
-                          onClick={async () => {
-                            await updateDefinitionsStatusByIdentity({
-                              data: {
-                                identity,
-                                status: "DISCARDED",
-                                discardedReason: `Duplicate of - ${uri}`,
-                              },
-                            });
-
-                            await queryClient.invalidateQueries({
-                              queryKey: ["definitionsByIdentity", identity],
-                            });
-
-                            alert("Marked duplicate is discarded");
-                            onClose();
-                          }}
-                        >
-                          Mark as duplicate
-                        </Button>
-                      </Group>
-
-                      <Box style={{ height: 220 }}>
-                        <iframe
-                          src={normalizeUri(uri)}
-                          style={{
-                            width: "100%",
-                            height: "100%",
-                            border: "none",
-                          }}
-                        />
-                      </Box>
-                    </Paper>
-                  );
-                })}
-              </Box>
-            </ScrollArea>
-          </Box>
-        </Box>
-
-        <Box
-          style={{
-            borderTop: "1px solid var(--mantine-color-gray-2)",
-            paddingTop: 10,
-            marginTop: 8,
-          }}
-        >
-          <Group justify="flex-end">
-            <Button
-              variant="default"
-              onClick={() => {
-                setDuplicates([]);
-                onClose();
-              }}
-            >
-              Cancel
-            </Button>
-          </Group>
-        </Box>
-      </Box>
-    </Modal>
-  );
-}
diff --git a/src/components/FinalizedDocumentsSection.tsx b/src/components/FinalizedDocumentsSection.tsx
index 6134630..edc76fd 100644
--- a/src/components/FinalizedDocumentsSection.tsx
+++ b/src/components/FinalizedDocumentsSection.tsx
@@ -35,10 +35,13 @@ export function FinalizedDocumentsSection() {
       to: "/create-latex",
       search: {
         documentId: doc.documentId,
+        definitionIds: [],
         futureRepo: doc.futureRepo,
         filePath: doc.filePath,
         fileName: doc.fileName,
         language: doc.language,
+        latexId: doc.id,
+        finalized: true,
       },
     });
   };
diff --git a/src/components/FtmlPreview.tsx b/src/components/FtmlPreview.tsx
index 9839476..463357d 100644
--- a/src/components/FtmlPreview.tsx
+++ b/src/components/FtmlPreview.tsx
@@ -1,5 +1,18 @@
 import { initFloDown } from "@/lib/flodownClient";
-import { FtmlStatement, normalizeToRoot } from "@/types/ftml.types";
+import { getDefiningDefinitions } from "@/serverFns/getSymbolUriMap.server";
+
+import {
+  DefiniendumNode,
+  DefinitionNode,
+  FtmlContent,
+  FtmlNode,
+  FtmlStatement,
+  isDefiniendumNode,
+  isDefinitionNode,
+  normalizeToRoot,
+  ParagraphNode,
+  SymrefNode,
+} from "@/types/ftml.types";
 import { useEffect, useRef } from "react";
 
 interface FtmlPreviewProps {
@@ -7,119 +20,234 @@ interface FtmlPreviewProps {
   docId: string;
 }
 
-function rewriteUris(node: any, uriMap: Map<string, string>): any {
-  if (Array.isArray(node)) {
-    return node.map((n) => rewriteUris(n, uriMap));
-  }
+type FloDownBlock = {
+  mountTo: (el: HTMLElement) => void;
+  addElement: (node: FtmlNode) => void;
+  addSymbolDeclaration: (name: string) => string;
+  getStex(): string;
+  getFtml(): string;
+  clear: () => void;
+  clearText: () => void;
+};
+
+function isHttpUri(uri: string): boolean {
+  return uri.startsWith("http://") || uri.startsWith("https://");
+}
 
-  if (!node || typeof node !== "object") return node;
+function collectExternalLabels(
+  node: FtmlNode | FtmlContent,
+  acc: Set<string>,
+): void {
+  if (typeof node === "string") return;
 
-  if (node.type === "definition") {
-    return {
-      ...node,
-      for_symbols: Array.isArray(node.for_symbols)
-        ? node.for_symbols.map((s: string) => uriMap.get(s) ?? s)
-        : node.for_symbols,
-      content: rewriteUris(node.content, uriMap),
-    };
+  if (node.type === "symref") {
+    const symref = node as SymrefNode;
+    if (symref.uri && !isHttpUri(symref.uri)) {
+      acc.add(symref.uri);
+    }
   }
 
-  if (node.type === "definiendum") {
-    return {
-      ...node,
-      uri: uriMap.get(node.uri) ?? node.uri,
-      content: rewriteUris(node.content, uriMap),
-    };
+  if (
+    isDefiniendumNode(node) &&
+    node.symdecl === false &&
+    node.uri &&
+    !isHttpUri(node.uri)
+  ) {
+    acc.add(node.uri);
   }
 
-  if (node.type === "symref") {
-    const symrefUri = node.uri;
-
-    if (typeof symrefUri === "string" && !symrefUri.startsWith("http")) {
-      const tempUri = `http://temp?a=temp&m=temp&s=${symrefUri}`;
-      return {
-        ...node,
-        uri: tempUri,
-        content: rewriteUris(node.content, uriMap),
-      };
+  if (node.content) {
+    for (const child of node.content) {
+      collectExternalLabels(child, acc);
     }
+  }
+}
 
-    return {
-      ...node,
-      uri: node.uri,
-      content: rewriteUris(node.content, uriMap),
-    };
+function rewriteDefinitionNode(
+  def: DefinitionNode,
+  uriMap: Map<string, string>,
+): DefinitionNode {
+  return {
+    ...def,
+    for_symbols: def.for_symbols.map((s) => uriMap.get(s) ?? s),
+    content: rewriteContentArray(def.content, uriMap),
+  };
+}
+
+function rewriteDefiniendumNode(
+  node: DefiniendumNode,
+  uriMap: Map<string, string>,
+): DefiniendumNode {
+  return {
+    ...node,
+    uri: uriMap.get(node.uri) ?? node.uri,
+    content: rewriteContentArray(node.content, uriMap),
+  };
+}
+
+function rewriteSymrefNode(
+  node: SymrefNode,
+  uriMap: Map<string, string>,
+): SymrefNode {
+  if (isHttpUri(node.uri)) return node;
+
+  const resolved = uriMap.get(node.uri);
+
+  if (!resolved) {
+    throw new Error(`Unresolved symbol: ${node.uri}`);
   }
 
+  return {
+    ...node,
+    uri: resolved,
+    content: rewriteContentArray(node.content, uriMap),
+  };
+}
+
+function rewriteFtmlNode(
+  node: FtmlNode,
+  uriMap: Map<string, string>,
+): FtmlNode {
+  if (isDefinitionNode(node)) return rewriteDefinitionNode(node, uriMap);
+  if (isDefiniendumNode(node)) return rewriteDefiniendumNode(node, uriMap);
+  if (node.type === "symref")
+    return rewriteSymrefNode(node as SymrefNode, uriMap);
+
   if (node.content) {
     return {
       ...node,
-      content: rewriteUris(node.content, uriMap),
+      content: rewriteContentArray(node.content, uriMap),
     };
   }
 
   return node;
 }
 
+function rewriteContentArray(
+  content: FtmlContent[],
+  uriMap: Map<string, string>,
+): FtmlContent[] {
+  return content.map((item) => {
+    if (typeof item === "string") return item;
+    return rewriteFtmlNode(item, uriMap);
+  });
+}
+
+type FloDownLib = {
+  setBackendUrl: (url: string) => void;
+  FloDown: { fromUri: (uri: string) => FloDownBlock };
+};
+
 export function FtmlPreview({ ftmlAst, docId }: FtmlPreviewProps) {
   const containerRef = useRef<HTMLDivElement>(null);
+  const hiddenRef = useRef<HTMLDivElement>(null);
+  const fdHiddenRef = useRef<FloDownBlock | null>(null);
+  const fdVisibleRef = useRef<FloDownBlock | null>(null);
 
   useEffect(() => {
-    if (!containerRef.current) return;
+    const containerEl = containerRef.current;
+    const hiddenEl = hiddenRef.current;
+
+    if (!containerEl || !hiddenEl) return;
 
     let disposed = false;
-    let fd: any = null;
 
     (async () => {
-      const floDown = await initFloDown();
-      if (disposed || !containerRef.current) return;
+      const floDown = (await initFloDown()) as FloDownLib;
+      if (disposed) return;
+
+      floDown.setBackendUrl("https://mathhub.info");
+      const fdHidden = floDown.FloDown.fromUri(
+        `http://temp-hidden?a=temp&d=${docId}&l=en`,
+      );
 
-      floDown.setBackendUrl("https://mmt.beta.vollki.kwarc.info");
+      hiddenEl.innerHTML = "";
+      fdHidden.mountTo(hiddenEl);
+      hiddenEl.style.display = "none";
 
-      fd = floDown.FloDown.fromUri(`http://temp?a=temp&d=${docId}&l=en`);
+      const fdVisible = floDown.FloDown.fromUri(
+        `http://temp-visible?a=temp&d=${docId}&l=en`,
+      );
 
-      containerRef.current.innerHTML = "";
-      fd.mountTo(containerRef.current);
+      fdHiddenRef.current = fdHidden;
+      fdVisibleRef.current = fdVisible;
+      containerEl.innerHTML = "";
+      fdVisible.mountTo(containerEl);
 
       const root = normalizeToRoot(ftmlAst);
       const block = root.content[0];
       if (!block) return;
 
       if (block.type === "paragraph") {
-        fd.addElement(block);
+        fdVisible.addElement(block as ParagraphNode);
         return;
       }
 
-      if (block.type !== "definition") return;
+      if (!isDefinitionNode(block)) return;
+
+      const defBlock = block as DefinitionNode;
+      const externalLabels = new Set<string>();
+      collectExternalLabels(defBlock, externalLabels);
+
+      const definingNodes =
+        externalLabels.size > 0
+          ? await getDefiningDefinitions({
+              data: { labels: Array.from(externalLabels) },
+            })
+          : {};
+
+      if (disposed) return;
 
       const uriMap = new Map<string, string>();
 
-      if (Array.isArray(block.for_symbols)) {
-        for (const symbolName of block.for_symbols) {
-          if (!symbolName.startsWith("http")) {
-            const declaredUri = fd.addSymbolDeclaration(symbolName);
-            uriMap.set(symbolName, declaredUri);
-          }
-        }
+      for (const [label, depDef] of Object.entries(definingNodes)) {
+        const uri = fdHidden.addSymbolDeclaration(label);
+        uriMap.set(label, uri);
+
+        const rewrittenDep = rewriteFtmlNode(depDef, uriMap);
+        fdHidden.addElement(rewrittenDep);
       }
 
-      const rewritten = rewriteUris(block, uriMap);
+      for (const symbolName of defBlock.for_symbols) {
+        if (!uriMap.has(symbolName)) {
+          const uriHidden = fdHidden.addSymbolDeclaration(symbolName);
+          fdVisible.addSymbolDeclaration(symbolName);
+
+          uriMap.set(symbolName, uriHidden);
+        }
+      }
 
-      fd.addElement(rewritten);
+      const rewritten = rewriteFtmlNode(defBlock, uriMap);
+      fdVisible.addElement(rewritten);
+      // console.log(fdVisible.getStex())
     })();
 
     return () => {
       disposed = true;
-      if (fd) {
+
+      if (fdHiddenRef.current) {
         try {
-          fd.clear();
+          fdHiddenRef.current.clear();
         } catch {}
+        fdHiddenRef.current = null;
       }
-      if (containerRef.current) {
-        containerRef.current.innerHTML = "";
+
+      if (fdVisibleRef.current) {
+        try {
+          fdVisibleRef.current.clear();
+        } catch {}
+        fdVisibleRef.current = null;
       }
-    };
-  }, [ftmlAst]);
 
-  return <div ref={containerRef} />;
+      if (containerEl) containerEl.innerHTML = "";
+      if (hiddenEl) hiddenEl.innerHTML = "";
+    };
+  }, [ftmlAst, docId]);
+
+  return (
+    <>
+      <div ref={hiddenRef} />
+      <div ref={containerRef} />
+    </>
+  );
 }
diff --git a/src/components/RenderUri.tsx b/src/components/RenderUri.tsx
index d1040cc..fe1fbad 100644
--- a/src/components/RenderUri.tsx
+++ b/src/components/RenderUri.tsx
@@ -1,4 +1,4 @@
-import { Badge, Group, Text } from "@mantine/core";
+import { Badge, Box, Group, Text, Tooltip } from "@mantine/core";
 import { IconArchive, IconBook, IconSchool } from "@tabler/icons-react";
 
 const ICON_SIZE = 14;
@@ -21,33 +21,49 @@ export function RenderSymbolicUri({ uri }: { uri: string }) {
     const definiensName = params.get(PARAM_DEFINIENS);
 
     if (!archiveName) {
-      return <Text size="xs">{uri}</Text>;
+      return (
+        <Tooltip label={uri} withArrow>
+          <Text size="xs" truncate>
+            {uri}
+          </Text>
+        </Tooltip>
+      );
     }
 
     const RightIcon = symbolName ? IconSchool : IconBook;
     const rightLabel = symbolName ?? definiensName;
 
     return (
-      <Group justify="space-between" wrap="nowrap" w="100%">
-        <Group gap={4} wrap="nowrap">
-          <IconArchive size={ICON_SIZE} stroke={ARCHIVE_ICON_STROKE} />
-          <Text size="xs" c="dimmed">
-            {archiveName}
-          </Text>
-        </Group>
+      <Tooltip label={uri} withArrow>
+        <Box style={{ width: "100%", overflow: "hidden" }}>
+          <Group justify="space-between" wrap="nowrap" w="100%">
+            <Group gap={4} wrap="nowrap">
+              <IconArchive size={ICON_SIZE} stroke={ARCHIVE_ICON_STROKE} />
+              <Text size="xs" c="dimmed" truncate>
+                {archiveName}
+              </Text>
+            </Group>
 
-        {rightLabel && (
-          <Group gap={4} wrap="nowrap">
-            <RightIcon size={ICON_SIZE} stroke={SYMBOL_ICON_STROKE} />
-            <Text size="xs" fw={500}>
-              {rightLabel}
-            </Text>
+            {rightLabel && (
+              <Group gap={4} wrap="nowrap">
+                <RightIcon size={ICON_SIZE} stroke={SYMBOL_ICON_STROKE} />
+                <Text size="xs" fw={500} truncate>
+                  {rightLabel}
+                </Text>
+              </Group>
+            )}
           </Group>
-        )}
-      </Group>
+        </Box>
+      </Tooltip>
     );
   } catch {
-    return <Text size="xs">{uri}</Text>;
+    return (
+      <Tooltip label={uri} withArrow>
+        <Text size="xs" truncate>
+          {uri}
+        </Text>
+      </Tooltip>
+    );
   }
 }
 
@@ -55,19 +71,21 @@ export function RenderDbSymbol({ symbol }: { symbol: DbSymbol }) {
   const filePath = `${symbol.futureRepo}`;
 
   return (
-    <Group justify="space-between" w="100%">
-      <Text size="xs" fw={500}>
-        {symbol.symbolName}
-      </Text>
-
-      <Group gap={4}>
-        <Badge size="xs" color="green">
-          DB
-        </Badge>
-        <Text size="xs" c="dimmed">
-          {filePath}
+    <Tooltip label={`${symbol.symbolName} • ${filePath}`} withArrow>
+      <Group justify="space-between" w="100%">
+        <Text size="xs" fw={500}>
+          {symbol.symbolName}
         </Text>
+
+        <Group gap={4}>
+          <Badge size="xs" color="green">
+            DB
+          </Badge>
+          <Text size="xs" c="dimmed" truncate>
+            {filePath}
+          </Text>
+        </Group>
       </Group>
-    </Group>
+    </Tooltip>
   );
 }
diff --git a/src/components/SemanticPanel.tsx b/src/components/SemanticPanel.tsx
index 3048d33..ccfb18a 100644
--- a/src/components/SemanticPanel.tsx
+++ b/src/components/SemanticPanel.tsx
@@ -1,5 +1,6 @@
-import { searchForDuplicateDefinition } from "@/server/ftml/searchForDuplicateDef";
 import { extractSemanticIndex } from "@/server/ftml/semanticIndex";
+import { ReplacePayload } from "@/server/parseUri";
+import { useSymbolSearch } from "@/server/useSymbolSearch";
 import { FtmlStatement } from "@/types/ftml.types";
 import {
   Box,
@@ -13,9 +14,10 @@ import {
   Stack,
   Text,
   TextInput,
+  Tooltip,
 } from "@mantine/core";
 import { useMemo, useState } from "react";
-import { RenderSymbolicUri } from "./RenderUri";
+import { RenderDbSymbol, RenderSymbolicUri } from "./RenderUri";
 
 type Props = {
   opened: boolean;
@@ -30,7 +32,7 @@ type Props = {
   onReplaceNode: (
     definitionId: string,
     target: { type: "definiendum" | "symref"; uri: string },
-    payload: any,
+    payload: ReplacePayload,
   ) => void;
   onDeleteNode: (
     definitionId: string,
@@ -51,6 +53,7 @@ export function SemanticPanel({
   onDeleteNode,
 }: Props) {
   const [selectedNode, setSelectedNode] = useState<SelectedNode>(null);
+  const [selectedUri, setSelectedUri] = useState("");
   const [searchInput, setSearchInput] = useState("");
   const [searchQuery, setSearchQuery] = useState("");
 
@@ -59,7 +62,7 @@ export function SemanticPanel({
     return extractSemanticIndex(definition.statement, definition);
   }, [definition]);
 
-  const { results, loading } = searchForDuplicateDefinition(searchQuery);
+  const { results, isLoading: loading } = useSymbolSearch(searchQuery);
 
   const selectedDefiniendum = definienda.find(
     (d) => d.uri === selectedNode?.uri,
@@ -67,10 +70,14 @@ export function SemanticPanel({
 
   const selectedSymref = symbolicRefs.find((s) => s.uri === selectedNode?.uri);
 
+  const canMakeNewSymbol =
+    selectedNode?.type === "definiendum" && !!selectedUri;
+
   function handleClose() {
     setSearchInput("");
     setSearchQuery("");
     setSelectedNode(null);
+    setSelectedUri("");
     onClose();
   }
 
@@ -111,12 +118,10 @@ export function SemanticPanel({
                     withBorder
                     bg={selectedNode?.uri === d.uri ? "blue.0" : undefined}
                     style={{ cursor: "pointer" }}
-                    onClick={() =>
-                      setSelectedNode({
-                        type: "definiendum",
-                        uri: d.uri,
-                      })
-                    }
+                    onClick={() => {
+                      setSelectedNode({ type: "definiendum", uri: d.uri });
+                      setSelectedUri(d.uri);
+                    }}
                   >
                     <Text size="sm" truncate>
                       {d.text}
@@ -137,12 +142,10 @@ export function SemanticPanel({
                     withBorder
                     bg={selectedNode?.uri === s.uri ? "teal.0" : undefined}
                     style={{ cursor: "pointer" }}
-                    onClick={() =>
-                      setSelectedNode({
-                        type: "symref",
-                        uri: s.uri,
-                      })
-                    }
+                    onClick={() => {
+                      setSelectedNode({ type: "symref", uri: s.uri });
+                      setSelectedUri("");
+                    }}
                   >
                     <Text size="sm" truncate>
                       {s.text}
@@ -186,13 +189,70 @@ export function SemanticPanel({
                     </Button>
                   </Group>
 
-                  <Text size="sm">Current URI: {selectedDefiniendum.uri}</Text>
+                  <Tooltip label={selectedDefiniendum.uri} withArrow>
+                    <Group gap={4} wrap="nowrap">
+                      {selectedDefiniendum.symdecl && (
+                        <Text size="xs" c="blue" fw={600}>
+                          NEW URI currently in use :
+                        </Text>
+                      )}
+
+                      <Box
+                        style={{
+                          maxWidth: 300,
+                          overflow: "hidden",
+                          textOverflow: "ellipsis",
+                          whiteSpace: "nowrap",
+                        }}
+                      >
+                        {selectedDefiniendum.uri.startsWith("http") ? (
+                          <RenderSymbolicUri uri={selectedDefiniendum.uri} />
+                        ) : (
+                          <RenderDbSymbol
+                            symbol={{
+                              symbolName: selectedDefiniendum.uri,
+                              source: "DB",
+                              futureRepo: "",
+                            }}
+                          />
+                        )}
+                      </Box>
+                    </Group>
+                  </Tooltip>
 
                   <Paper withBorder p="sm">
                     <Group justify="space-between">
                       <Text size="sm">{selectedDefiniendum.text}</Text>
 
                       <Group gap={6}>
+                        <Button
+                          size="xs"
+                          style={{ flexShrink: 0 }}
+                          disabled={!canMakeNewSymbol}
+                          onClick={() => {
+                            const newUri = selectedUri;
+                            onReplaceNode(
+                              definition.id,
+                              {
+                                type: "definiendum",
+                                uri: selectedDefiniendum.uri,
+                              },
+                              {
+                                type: "definiendum",
+                                uri: selectedUri,
+                                symdecl: true,
+                              },
+                            );
+                            setSelectedNode({
+                              type: "definiendum",
+                              uri: newUri,
+                            });
+                            setSelectedUri("");
+                          }}
+                        >
+                          Make new symbol
+                        </Button>
+
                         <Button
                           size="xs"
                           color="red"
@@ -224,49 +284,170 @@ export function SemanticPanel({
                       </Group>
                     )}
 
-                    {!loading &&
-                      results.map((uri) => (
-                        <Paper key={uri} withBorder p="xs" m="xs">
-                          <Group gap="xs" wrap="nowrap">
-                            <Box style={{ flex: 1, minWidth: 0 }}>
-                              <RenderSymbolicUri uri={uri} />
-                            </Box>
-
-                            <Button
-                              size="xs"
-                              style={{ flexShrink: 0 }}
-                              onClick={() =>
-                                onReplaceNode(
-                                  definition.id,
-                                  {
-                                    type: "definiendum",
-                                    uri: selectedDefiniendum.uri,
-                                  },
-                                  {
-                                    type: "definiendum",
-                                    uri,
-                                    content: [uri],
-                                    symdecl: false,
-                                  },
-                                )
-                              }
-                            >
-                              Use this
-                            </Button>
-                          </Group>
-
-                          <Box mt="xs" h={160}>
-                            <iframe
-                              src={uri.replace('http:','https:')}
-                              style={{
-                                width: "100%",
-                                height: "100%",
-                                border: "none",
-                              }}
-                            />
-                          </Box>
-                        </Paper>
-                      ))}
+                    {!loading && (
+                      <>
+                        {results.filter((r) => r.source === "DB").length >
+                          0 && (
+                          <Stack gap="xs">
+                            <Text size="xs" fw={600} c="dimmed">
+                              Local DB
+                            </Text>
+
+                            {results
+                              .filter((r) => r.source === "DB")
+                              .map((r) => (
+                                <Paper
+                                  key={r.id}
+                                  withBorder
+                                  p="xs"
+                                  style={{ cursor: "pointer" }}
+                                  bg={
+                                    selectedUri === r.symbolName
+                                      ? "blue.0"
+                                      : undefined
+                                  }
+                                  onClick={() => setSelectedUri(r.symbolName)}
+                                >
+                                  <Group
+                                    justify="space-between"
+                                    wrap="nowrap"
+                                    align="center"
+                                  >
+                                    <Box
+                                      style={{
+                                        flex: 1,
+                                        minWidth: 0,
+                                        overflow: "hidden",
+                                      }}
+                                    >
+                                      <RenderDbSymbol
+                                        symbol={{
+                                          symbolName: r.symbolName,
+                                          source: "DB",
+                                          futureRepo: r.futureRepo,
+                                        }}
+                                      />
+                                    </Box>
+
+                                    <Button
+                                      size="xs"
+                                      style={{ flexShrink: 0 }}
+                                      onClick={(e) => {
+                                        e.stopPropagation();
+
+                                        const newUri = r.symbolName;
+
+                                        onReplaceNode(
+                                          definition.id,
+                                          {
+                                            type: "definiendum",
+                                            uri: selectedDefiniendum.uri,
+                                          },
+                                          {
+                                            type: "definiendum",
+                                            uri: newUri,
+                                            symdecl: false,
+                                          },
+                                        );
+
+                                        setSelectedNode({
+                                          type: "definiendum",
+                                          uri: newUri,
+                                        });
+                                        setSelectedUri(newUri);
+                                      }}
+                                    >
+                                      Use this
+                                    </Button>
+                                  </Group>
+                                </Paper>
+                              ))}
+                          </Stack>
+                        )}
+
+                        {results.filter((r) => r.source === "MATHHUB").length >
+                          0 && (
+                          <Stack gap="xs" mt="sm">
+                            <Text size="xs" fw={600} c="dimmed">
+                              MathHub
+                            </Text>
+
+                            {results
+                              .filter((r) => r.source === "MATHHUB")
+                              .map((r) => (
+                                <Paper
+                                  key={r.uri}
+                                  withBorder
+                                  p="xs"
+                                  style={{ cursor: "pointer" }}
+                                  bg={
+                                    selectedUri === r.uri ? "blue.0" : undefined
+                                  }
+                                  onClick={() => setSelectedUri(r.uri)}
+                                >
+                                  <Group
+                                    justify="space-between"
+                                    wrap="nowrap"
+                                    align="center"
+                                  >
+                                    <Box
+                                      style={{
+                                        flex: 1,
+                                        minWidth: 0,
+                                        overflow: "hidden",
+                                      }}
+                                    >
+                                      <RenderSymbolicUri uri={r.uri} />
+                                    </Box>
+
+                                    <Button
+                                      size="xs"
+                                      style={{ flexShrink: 0 }}
+                                      onClick={(e) => {
+                                        e.stopPropagation();
+
+                                        const newUri = r.uri;
+
+                                        onReplaceNode(
+                                          definition.id,
+                                          {
+                                            type: "definiendum",
+                                            uri: selectedDefiniendum.uri,
+                                          },
+                                          {
+                                            type: "definiendum",
+                                            uri: newUri,
+                                            symdecl: false,
+                                          },
+                                        );
+
+                                        setSelectedNode({
+                                          type: "definiendum",
+                                          uri: newUri,
+                                        });
+                                        setSelectedUri(newUri);
+                                      }}
+                                    >
+                                      Use this
+                                    </Button>
+                                  </Group>
+
+                                  <Box mt="xs" h={140}>
+                                    <iframe
+                                      src={r.uri.replace("http:", "https:")}
+                                      style={{
+                                        width: "100%",
+                                        height: "100%",
+                                        border: "none",
+                                      }}
+                                    />
+                                  </Box>
+                                </Paper>
+                              ))}
+                          </Stack>
+                        )}
+                      </>
+                    )}
                   </Box>
                 </Stack>
               )}
@@ -288,7 +469,32 @@ export function SemanticPanel({
                     </Button>
                   </Group>
 
-                  <Text size="sm">Current URI: {selectedSymref.uri}</Text>
+                  <Group gap={6} wrap="nowrap">
+                    <Text size="sm">Current URI:</Text>
+
+                    <Tooltip label={selectedSymref.uri} withArrow>
+                      <Box
+                        style={{
+                          maxWidth: 300,
+                          overflow: "hidden",
+                          textOverflow: "ellipsis",
+                          whiteSpace: "nowrap",
+                        }}
+                      >
+                        {selectedSymref.uri.startsWith("http") ? (
+                          <RenderSymbolicUri uri={selectedSymref.uri} />
+                        ) : (
+                          <RenderDbSymbol
+                            symbol={{
+                              symbolName: selectedSymref.uri,
+                              source: "DB",
+                              futureRepo: "",
+                            }}
+                          />
+                        )}
+                      </Box>
+                    </Tooltip>
+                  </Group>
 
                   <Paper withBorder p="sm">
                     <Group justify="space-between">
@@ -326,43 +532,126 @@ export function SemanticPanel({
                       </Group>
                     )}
 
-                    {!loading &&
-                      results.map((uri) => (
-                        <Paper key={uri} withBorder p="xs" m="xs">
-                          <Group gap="xs" wrap="nowrap">
-                            <RenderSymbolicUri uri={uri} />
-
-                            <Button
-                              size="xs"
-                              style={{ flexShrink: 0 }}
-                              onClick={() =>
-                                onReplaceNode(
-                                  definition.id,
-                                  { type: "symref", uri: selectedSymref.uri },
-                                  {
-                                    type: "symref",
-                                    uri,
-                                    content: [uri],
-                                  },
-                                )
-                              }
-                            >
-                              Use this
-                            </Button>
-                          </Group>
-
-                          <Box mt="xs" h={160}>
-                            <iframe
-                              src={uri}
-                              style={{
-                                width: "100%",
-                                height: "100%",
-                                border: "none",
-                              }}
-                            />
-                          </Box>
-                        </Paper>
-                      ))}
+                    {!loading && (
+                      <>
+                        {results.filter((r) => r.source === "DB").length >
+                          0 && (
+                          <Stack gap="xs">
+                            <Text size="xs" fw={600} c="dimmed">
+                              Local DB
+                            </Text>
+
+                            {results
+                              .filter((r) => r.source === "DB")
+                              .map((r) => (
+                                <Paper key={r.id} withBorder p="xs">
+                                  <Group
+                                    justify="space-between"
+                                    wrap="nowrap"
+                                    align="center"
+                                  >
+                                    <RenderDbSymbol
+                                      symbol={{
+                                        symbolName: r.symbolName,
+                                        source: "DB",
+                                        futureRepo: r.futureRepo,
+                                      }}
+                                    />
+
+                                    <Button
+                                      size="xs"
+                                      style={{ flexShrink: 0 }}
+                                      onClick={() => {
+                                        const newUri = r.symbolName;
+
+                                        onReplaceNode(
+                                          definition.id,
+                                          {
+                                            type: "symref",
+                                            uri: selectedSymref.uri,
+                                          },
+                                          {
+                                            type: "symref",
+                                            uri: newUri,
+                                          },
+                                        );
+
+                                        setSelectedNode({
+                                          type: "symref",
+                                          uri: newUri,
+                                        });
+                                      }}
+                                    >
+                                      Use this
+                                    </Button>
+                                  </Group>
+                                </Paper>
+                              ))}
+                          </Stack>
+                        )}
+
+                        {results.filter((r) => r.source === "MATHHUB").length >
+                          0 && (
+                          <Stack gap="xs" mt="sm">
+                            <Text size="xs" fw={600} c="dimmed">
+                              MathHub
+                            </Text>
+
+                            {results
+                              .filter((r) => r.source === "MATHHUB")
+                              .map((r) => (
+                                <Paper key={r.uri} withBorder p="xs">
+                                  <Group
+                                    justify="space-between"
+                                    wrap="nowrap"
+                                    align="center"
+                                  >
+                                    <RenderSymbolicUri uri={r.uri} />
+
+                                    <Button
+                                      size="xs"
+                                      style={{ flexShrink: 0 }}
+                                      onClick={() => {
+                                        const newUri = r.uri;
+
+                                        onReplaceNode(
+                                          definition.id,
+                                          {
+                                            type: "symref",
+                                            uri: selectedSymref.uri,
+                                          },
+                                          {
+                                            type: "symref",
+                                            uri: newUri,
+                                          },
+                                        );
+
+                                        setSelectedNode({
+                                          type: "symref",
+                                          uri: newUri,
+                                        });
+                                      }}
+                                    >
+                                      Use this
+                                    </Button>
+                                  </Group>
+
+                                  <Box mt="xs" h={140}>
+                                    <iframe
+                                      src={r.uri}
+                                      style={{
+                                        width: "100%",
+                                        height: "100%",
+                                        border: "none",
+                                      }}
+                                    />
+                                  </Box>
+                                </Paper>
+                              ))}
+                          </Stack>
+                        )}
+                      </>
+                    )}
                   </Box>
                 </Stack>
               )}
diff --git a/src/components/StexCuration.tsx b/src/components/StexCuration.tsx
index def3df6..0c7472b 100644
--- a/src/components/StexCuration.tsx
+++ b/src/components/StexCuration.tsx
@@ -562,13 +562,11 @@ export function StexCuration({ identity }: { identity: FileIdentity }) {
                     <Menu.Dropdown>
                       <Menu.Label>Status Actions</Menu.Label>
                       <Menu.Item
-                        color="red"
-                        disabled={status !== "SUBMITTED_TO_MATHHUB"}
                         onClick={async () => {
                           await updateDefinitionsStatusByIdentity({
                             data: {
                               identity,
-                              status: "FINALIZED_IN_FILE",
+                              status: "EXTRACTED",
                             },
                           });
 
@@ -586,10 +584,7 @@ export function StexCuration({ identity }: { identity: FileIdentity }) {
                       >
                         Extracted
                       </Menu.Item>
-
                       <Menu.Item
-                        color="red"
-                        disabled={status !== "SUBMITTED_TO_MATHHUB"}
                         onClick={async () => {
                           await updateDefinitionsStatusByIdentity({
                             data: {
@@ -613,7 +608,6 @@ export function StexCuration({ identity }: { identity: FileIdentity }) {
                         Finalized
                       </Menu.Item>
                       <Menu.Item
-                        disabled={status !== "FINALIZED_IN_FILE"}
                         onClick={async () => {
                           await updateDefinitionsStatusByIdentity({
                             data: {
diff --git a/src/routes/__root.tsx b/src/routes/__root.tsx
index ab91fb8..4ee22f7 100644
--- a/src/routes/__root.tsx
+++ b/src/routes/__root.tsx
@@ -1,13 +1,11 @@
+import { MainLayout } from "@/components/MainLayout";
+import { initFtmlClient } from "@/lib/ftmlClient";
+import { queryClient } from "@/queryClient";
 import { AppShell, MantineProvider } from "@mantine/core";
 import "@mantine/core/styles.css";
-import { TanStackDevtools } from "@tanstack/react-devtools";
 import { QueryClientProvider } from "@tanstack/react-query";
 import { HeadContent, Scripts, createRootRoute } from "@tanstack/react-router";
-import { TanStackRouterDevtoolsPanel } from "@tanstack/react-router-devtools";
-import { queryClient } from "@/queryClient";
 import Header from "../components/Header";
-import { MainLayout } from "@/components/MainLayout";
-import { initFtmlClient } from "@/lib/ftmlClient";
 
 function NotFound() {
   return (
diff --git a/src/routes/create-latex.tsx b/src/routes/create-latex.tsx
index bcf198e..a1ad46e 100644
--- a/src/routes/create-latex.tsx
+++ b/src/routes/create-latex.tsx
@@ -1,7 +1,10 @@
 import { currentUser } from "@/server/auth/currentUser";
 import { injectProvenance } from "@/server/ftml/addProvenanceData";
 import { generateStexFromFtml } from "@/server/ftml/generateStexFromFtml";
-import { getCombinedDefinitionFtml } from "@/serverFns/definitionAggregate.server";
+import {
+  getCombinedDefinitionFtml,
+  getFinalizedLatexById,
+} from "@/serverFns/definitionAggregate.server";
 import { getDefinitionProvenance } from "@/serverFns/definitionProvenance.server";
 import {
   getDefinitionFileStatus,
@@ -40,6 +43,8 @@ type CreateLatexSearch = {
   filePath: string;
   fileName: string;
   language: string;
+  finalized?: boolean;
+  latexId?: string;
 };
 
 export const Route = createFileRoute("/create-latex")({
@@ -74,6 +79,8 @@ function CreateLatexPage() {
     filePath,
     fileName,
     language,
+    finalized,
+    latexId,
   } = Route.useSearch();
 
   const [editedLatex, setEditedLatex] = useState<string | null>(null);
@@ -102,13 +109,20 @@ function CreateLatexPage() {
           language,
         },
       }),
+    enabled: !finalized && definitionIds.length > 0,
+  });
+
+  const { data: finalizedData, isLoading: finalizedLoading } = useQuery({
+    queryKey: ["finalized-latex", latexId],
+    queryFn: () => getFinalizedLatexById({ data: { id: latexId! } }),
+    enabled: finalized === true && !!latexId,
   });
 
   const { data: stex, isLoading: stexLoading } = useQuery({
     queryKey: ["stex", ftmlAst],
     queryFn: () =>
       generateStexFromFtml(ftmlAst!, futureRepo, filePath, fileName),
-    enabled: !!ftmlAst,
+    enabled: !finalized && !!ftmlAst,
     staleTime: Infinity,
   });
 
@@ -136,6 +150,7 @@ function CreateLatexPage() {
           language,
         },
       }),
+    enabled: !finalized,
   });
 
   const { data: provenance } = useQuery({
@@ -151,6 +166,7 @@ function CreateLatexPage() {
           language,
         },
       }),
+    enabled: !finalized,
   });
 
   const { data: definitionStatus } = useQuery({
@@ -179,15 +195,16 @@ function CreateLatexPage() {
   const generatedLatex =
     stex && provenance ? injectProvenance(stex, provenance) : (stex ?? "");
 
-  const displayLatex =
-    editedLatex ?? generatedLatex ?? historyData?.finalLatex ?? "";
+  const displayLatex = finalized
+    ? (finalizedData?.latex ?? "")
+    : (editedLatex ?? generatedLatex ?? historyData?.finalLatex ?? "");
 
-  if (ftmlLoading || stexLoading) {
+  if (!finalized && (ftmlLoading || stexLoading)) {
     return (
       <Box p="xl" h="100dvh">
         <Stack align="center" justify="center" h="100%">
           <Loader size="xl" />
-          <Text>Generating sTeX…</Text>
+          <Text>Loading sTeX…</Text>
         </Stack>
       </Box>
     );
@@ -247,7 +264,7 @@ function CreateLatexPage() {
     }
   };
 
-  if (stexLoading) {
+  if (stexLoading || finalizedLoading) {
     return (
       <Box p="xl" h="100dvh">
         <Stack align="center" justify="center" h="100%">
@@ -258,6 +275,11 @@ function CreateLatexPage() {
     );
   }
 
+  const isLocked =
+    finalized ||
+    status === "FINALIZED_IN_FILE" ||
+    status === "SUBMITTED_TO_MATHHUB";
+
   return (
     <Box p="xl" h="100dvh">
       <Stack h="100%" gap="lg">
@@ -308,10 +330,7 @@ function CreateLatexPage() {
                 size="xs"
                 variant="light"
                 onClick={() => setHistoryOpen(true)}
-                disabled={
-                  status === "FINALIZED_IN_FILE" ||
-                  status === "SUBMITTED_TO_MATHHUB"
-                }
+                disabled={isLocked}
               >
                 Version History
               </Button>
@@ -353,10 +372,7 @@ function CreateLatexPage() {
 
         <Paper withBorder style={{ flex: 1 }}>
           <Textarea
-            readOnly={
-              status === "FINALIZED_IN_FILE" ||
-              status === "SUBMITTED_TO_MATHHUB"
-            }
+            readOnly={isLocked}
             value={displayLatex}
             onChange={(e) => {
               setEditedLatex(e.currentTarget.value);
@@ -401,11 +417,7 @@ function CreateLatexPage() {
               <Button
                 onClick={handleSaveDraft}
                 loading={savingDraft}
-                disabled={
-                  isFromHistory ||
-                  status === "FINALIZED_IN_FILE" ||
-                  status === "SUBMITTED_TO_MATHHUB"
-                }
+                disabled={isFromHistory || isLocked}
               >
                 Save Draft
               </Button>
@@ -415,10 +427,7 @@ function CreateLatexPage() {
                 gradient={{ from: "violet", to: "grape" }}
                 onClick={handleSaveFinal}
                 loading={savingFinal}
-                disabled={
-                  status === "FINALIZED_IN_FILE" ||
-                  status === "SUBMITTED_TO_MATHHUB"
-                }
+                disabled={isLocked}
               >
                 Save Final
               </Button>
diff --git a/src/server/auth/isAdmin.ts b/src/server/auth/isAdmin.ts
index d86806b..79bf1af 100644
--- a/src/server/auth/isAdmin.ts
+++ b/src/server/auth/isAdmin.ts
@@ -35,7 +35,7 @@ export const adminUser = createServerFn({ method: "GET" }).handler(async () => {
 
   return {
     loggedIn: true,
-    isAdmin: user.role === "ADMIN",
+    isAdmin: user.role === "ADMIN" || user.role==="CURATOR",
     user: {
       id: user.id,
       email: user.email,
diff --git a/src/server/ftml/generateStexFromFtml.ts b/src/server/ftml/generateStexFromFtml.ts
index d4cc069..e3106d5 100644
--- a/src/server/ftml/generateStexFromFtml.ts
+++ b/src/server/ftml/generateStexFromFtml.ts
@@ -1,13 +1,19 @@
 import { initFloDown } from "@/lib/flodownClient";
+import { getDefiningDefinitions } from "@/serverFns/getSymbolUriMap.server";
 import {
   DefiniendumNode,
   DefinitionNode,
   FtmlContent,
   FtmlNode,
   FtmlStatement,
+  isDefiniendumNode,
   normalizeToRoot,
 } from "@/types/ftml.types";
 
+function isHttp(uri: string) {
+  return uri.startsWith("http://") || uri.startsWith("https://");
+}
+
 function isMathHubUri(uri: string): boolean {
   return (
     uri.startsWith("http://mathhub.info?") ||
@@ -15,6 +21,30 @@ function isMathHubUri(uri: string): boolean {
   );
 }
 
+function collectExternalLabels(
+  node: FtmlNode | FtmlContent,
+  acc: Set<string>,
+): void {
+  if (typeof node === "string") return;
+
+  if (node.type === "symref" && node.uri && !isHttp(node.uri)) {
+    acc.add(node.uri);
+  }
+
+  if (
+    isDefiniendumNode(node) &&
+    node.symdecl === false &&
+    node.uri &&
+    !isHttp(node.uri)
+  ) {
+    acc.add(node.uri);
+  }
+
+  if (node.content) {
+    node.content.forEach((c) => collectExternalLabels(c, acc));
+  }
+}
+
 function finalFTML(
   node: FtmlNode,
   uriMap: Map<string, string>,
@@ -24,12 +54,11 @@ function finalFTML(
 ): FtmlNode {
   if (node.type === "definition") {
     const def = node as DefinitionNode;
-
     return {
       ...def,
       for_symbols: def.for_symbols.map((s) => uriMap.get(s) ?? s),
-      content: rewriteContent(
-        def.content,
+      content: rewrite(
+        node.content ?? [],
         uriMap,
         futureRepo,
         filePath,
@@ -39,21 +68,14 @@ function finalFTML(
   }
 
   if (node.type === "definiendum") {
-    const defNode = node as DefiniendumNode;
-
-    if (
-      defNode.symdecl === false &&
-      defNode.uri &&
-      !defNode.uri.startsWith("http")
-    ) {
-      const symbolName = defNode.uri;
-      const tempUri = `http://${futureRepo}?a=${filePath}&m=${fileName}&s=${symbolName}`;
+    const n = node as DefiniendumNode;
 
+    if (!n.symdecl && n.uri && !isHttp(n.uri)) {
       return {
-        ...defNode,
-        uri: tempUri,
-        content: rewriteContent(
-          defNode.content ?? [],
+        ...n,
+        uri: `http://${futureRepo}?a=${filePath}&m=${fileName}&s=${n.uri}`,
+        content: rewrite(
+          n.content ?? [],
           uriMap,
           futureRepo,
           filePath,
@@ -63,29 +85,20 @@ function finalFTML(
     }
 
     return {
-      ...defNode,
-      uri: uriMap.get(defNode.uri!) ?? defNode.uri,
-      content: rewriteContent(
-        defNode.content ?? [],
-        uriMap,
-        futureRepo,
-        filePath,
-        fileName,
-      ),
+      ...n,
+      uri: uriMap.get(n.uri!) ?? n.uri,
+      content: rewrite(n.content ?? [], uriMap, futureRepo, filePath, fileName),
     };
   }
 
   if (node.type === "symref") {
-    const symrefUri = node.uri;
-
-    if (symrefUri && !isMathHubUri(symrefUri)) {
-      const symbolName = symrefUri;
-      const tempUri = `http://${futureRepo}?a=${filePath}&m=${fileName}&s=${symbolName}`;
+    const u = node.uri;
 
+    if (u && !isMathHubUri(u)) {
       return {
         ...node,
-        uri: tempUri,
-        content: rewriteContent(
+        uri: `http://${futureRepo}?a=${filePath}&m=${fileName}&s=${u}`,
+        content: rewrite(
           node.content ?? [],
           uriMap,
           futureRepo,
@@ -98,7 +111,7 @@ function finalFTML(
     return {
       ...node,
       uri: uriMap.get(node.uri!) ?? node.uri,
-      content: rewriteContent(
+      content: rewrite(
         node.content ?? [],
         uriMap,
         futureRepo,
@@ -111,64 +124,25 @@ function finalFTML(
   if (node.content) {
     return {
       ...node,
-      content: rewriteContent(
-        node.content,
-        uriMap,
-        futureRepo,
-        filePath,
-        fileName,
-      ),
+      content: rewrite(node.content, uriMap, futureRepo, filePath, fileName),
     };
   }
 
   return node;
 }
 
-function rewriteContent(
+function rewrite(
   content: FtmlContent[],
   uriMap: Map<string, string>,
   futureRepo: string,
   filePath: string,
   fileName: string,
 ): FtmlContent[] {
-  return content.map((item) => {
-    if (typeof item === "string") return item;
-
-    return finalFTML(item, uriMap, futureRepo, filePath, fileName);
-  });
-}
-
-function collectSymbolsToRemove(content: FtmlContent[]): Set<string> {
-  const toRemove = new Set<string>();
-
-  for (const item of content) {
-    if (typeof item === "string") continue;
-
-    if (item.type === "definiendum") {
-      const defNode = item as DefiniendumNode;
-      if (
-        defNode.symdecl === false &&
-        defNode.uri &&
-        !defNode.uri.startsWith("http")
-      ) {
-        toRemove.add(defNode.uri);
-      }
-    }
-
-    if (item.type === "symref") {
-      const symrefUri = item.uri;
-      if (symrefUri && !isMathHubUri(symrefUri)) {
-        toRemove.add(symrefUri);
-      }
-    }
-
-    if (item.content) {
-      const nested = collectSymbolsToRemove(item.content);
-      nested.forEach((s) => toRemove.add(s));
-    }
-  }
-
-  return toRemove;
+  return content.map((c) =>
+    typeof c === "string"
+      ? c
+      : finalFTML(c, uriMap, futureRepo, filePath, fileName),
+  );
 }
 
 export async function generateStexFromFtml(
@@ -179,50 +153,67 @@ export async function generateStexFromFtml(
 ): Promise<string> {
   const floDown = await initFloDown();
   floDown.setBackendUrl("https://mmt.beta.vollki.kwarc.info");
-  const fd = floDown.FloDown.fromUri(
-    `http://=${futureRepo}?a==${filePath}&d=${fileName}&l=en`,
+
+  const fdHidden = floDown.FloDown.fromUri(
+    `http://hidden?a=temp&d=${fileName}&l=en`,
+  );
+
+  const fdVisible = floDown.FloDown.fromUri(
+    `http://${futureRepo}?a=${filePath}&d=${fileName}&l=en`,
   );
 
   const root = normalizeToRoot(ftmlAst);
 
   for (const block of root.content) {
     if (block.type === "paragraph") {
-      fd.addElement(block);
+      fdVisible.addElement(block);
       continue;
     }
 
     if (block.type !== "definition") continue;
 
     const def = block as DefinitionNode;
-    const symbolsToRemove = collectSymbolsToRemove(def.content);
 
-    const filteredForSymbols = def.for_symbols.filter(
-      (symbolName) => !symbolsToRemove.has(symbolName),
-    );
+    const external = new Set<string>();
+    collectExternalLabels(def, external);
+
+    const deps =
+      external.size > 0
+        ? await getDefiningDefinitions({
+            data: { labels: Array.from(external) },
+          })
+        : {};
 
     const uriMap = new Map<string, string>();
 
-    for (const symbolName of filteredForSymbols) {
-      if (!symbolName.startsWith("http")) {
-        const declaredUri = fd.addSymbolDeclaration(symbolName);
-        uriMap.set(symbolName, declaredUri);
-      }
-    }
+    for (const [label, depDef] of Object.entries(deps)) {
+      const uri = fdHidden.addSymbolDeclaration(label);
+      uriMap.set(label, uri);
 
-    const transformedDef = {
-      ...def,
-      for_symbols: filteredForSymbols.map((s) => uriMap.get(s) ?? s),
-      content: rewriteContent(
-        def.content,
+      const rewritten = finalFTML(
+        depDef,
         uriMap,
         futureRepo,
         filePath,
         fileName,
-      ),
-    };
+      );
+
+      fdHidden.addElement(rewritten);
+    }
+
+    for (const symbol of def.for_symbols) {
+      if (!uriMap.has(symbol) && !symbol.startsWith("http")) {
+        const hiddenUri = fdHidden.addSymbolDeclaration(symbol);
+        fdVisible.addSymbolDeclaration(symbol);
+
+        uriMap.set(symbol, hiddenUri);
+      }
+    }
+
+    const rewritten = finalFTML(def, uriMap, futureRepo, filePath, fileName);
 
-    fd.addElement(transformedDef);
+    fdVisible.addElement(rewritten);
   }
 
-  return fd.getStex();
+  return fdVisible.getStex();
 }
diff --git a/src/server/ftml/searchForDuplicateDef.ts b/src/server/ftml/searchForDuplicateDef.ts
deleted file mode 100644
index c55557a..0000000
--- a/src/server/ftml/searchForDuplicateDef.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import { ftmlSearchSymbols } from "@/server/ftml/searchSymbols"
-import { useQuery } from "@tanstack/react-query"
-
-const MIN_SEARCH_LENGTH = 2
-const LIMIT = 15
-
-export function searchForDuplicateDefinition(query: string) {
-  const valid = query.trim().length >= MIN_SEARCH_LENGTH
-
-  const { data = [], isFetching } = useQuery({
-    queryKey: ["mathhub-symbol-search", query],
-    queryFn: () => ftmlSearchSymbols(query, LIMIT),
-    enabled: valid,
-  })
-
-  return {
-    results: data,
-    loading: isFetching,
-    ready: !isFetching,
-    hasResults: data.length > 0,
-  }
-}
\ No newline at end of file
diff --git a/src/server/ftml/semanticIndex.ts b/src/server/ftml/semanticIndex.ts
index bcc7c4c..77e80d0 100644
--- a/src/server/ftml/semanticIndex.ts
+++ b/src/server/ftml/semanticIndex.ts
@@ -1,10 +1,16 @@
 import { extractTextContent } from "@/server/ftml/astOperations";
-import { FtmlNode, FtmlRoot, normalizeToRoot } from "@/types/ftml.types";
+import {
+  FtmlNode,
+  FtmlRoot,
+  isDefiniendumNode,
+  normalizeToRoot,
+} from "@/types/ftml.types";
 
 export type DefiniendumInfo = {
   uri: string;
   text: string;
   symbolId: string;
+  symdecl: boolean;
 };
 
 export type SymbolicRefInfo = {
@@ -16,7 +22,7 @@ export type SymbolicRefInfo = {
 function walk(
   node: FtmlNode | FtmlNode[],
   acc: {
-    definienda: { uri: string; text: string }[];
+    definienda: { uri: string; text: string; symdecl: boolean }[];
     symrefs: { uri: string; text: string }[];
   },
 ): void {
@@ -24,11 +30,11 @@ function walk(
     node.forEach((n) => walk(n, acc));
     return;
   }
-
-  if (node.type === "definiendum") {
+  if (isDefiniendumNode(node)) {
     acc.definienda.push({
       uri: node.uri!,
       text: extractTextContent(node.content ?? []),
+      symdecl: !!node.symdecl,
     });
   }
 
@@ -59,7 +65,7 @@ export function extractSemanticIndex(
   const root = normalizeToRoot(statement);
 
   const collected = {
-    definienda: [] as { uri: string; text: string }[],
+    definienda: [] as { uri: string; text: string; symdecl: boolean }[],
     symrefs: [] as { uri: string; text: string }[],
   };
 
@@ -68,6 +74,7 @@ export function extractSemanticIndex(
   const definienda = collected.definienda.map((d) => ({
     ...d,
     symbolId: d.uri,
+    symdecl: d.symdecl,
   }));
 
   const symbolicRefs = collected.symrefs.map((r) => {
@@ -76,9 +83,12 @@ export function extractSemanticIndex(
     );
 
     if (!match) {
-      throw new Error(`SymbolicRef "${r.uri}" exists in AST but not linked`);
+      return {
+        ...r,
+        symbolicRefId: null,
+        unlinked: true,
+      };
     }
-
     return {
       ...r,
       symbolicRefId: match.symbolicReference.id,
diff --git a/src/server/parseUri.ts b/src/server/parseUri.ts
index a41980b..3c3386d 100644
--- a/src/server/parseUri.ts
+++ b/src/server/parseUri.ts
@@ -1,21 +1,12 @@
 import type { UnifiedSymbolicReference } from "@/server/document/SymbolicRef.types";
 import type {
+  DefiniendumNode,
   DefinitionNode,
   FtmlContent,
   FtmlNode,
   FtmlRoot,
 } from "@/types/ftml.types";
 
-export function uriToSymbolName(uri: string): string {
-  if (uri.startsWith("LOCAL:")) return uri.slice("LOCAL:".length);
-  try {
-    const url = new URL(uri);
-    return url.searchParams.get("s") || uri;
-  } catch {
-    return uri;
-  }
-}
-
 export type ParsedMathHubUri = {
   archive: string;
   filePath: string;
@@ -25,12 +16,27 @@ export type ParsedMathHubUri = {
   conceptUri: string;
 };
 
+export type ReplaceDefiniendumPayload = {
+  type: "definiendum";
+  uri: string;
+  content?: FtmlContent[];
+  symdecl: boolean;
+};
+
+export type ReplaceSymrefPayload = {
+  type: "symref";
+  uri: string;
+  content?: FtmlContent[];
+};
+
+export type ReplacePayload = ReplaceDefiniendumPayload | ReplaceSymrefPayload;
+
 export function parseUri(uri: string): ParsedMathHubUri {
   const url = new URL(uri);
   const params = url.searchParams;
   return {
     archive: params.get("a") || "",
-    filePath: params.get("f") || "",
+    filePath: params.get("p") || "",
     fileName: params.get("d") || "",
     language: params.get("l") || "en",
     symbol: params.get("s") || "",
@@ -46,7 +52,7 @@ export function normalizeSymRef(symRef: UnifiedSymbolicReference): {
     const parsed = parseUri(symRef.uri);
     return { uri: parsed.conceptUri, text: parsed.symbol };
   }
-  return { uri: `LOCAL:${symRef.symbolName}`, text: symRef.symbolName };
+  return { uri: `${symRef.symbolName}`, text: symRef.symbolName };
 }
 
 function normalizeContent(content: FtmlContent[]): FtmlContent[] {
@@ -79,7 +85,7 @@ type RemoveSemanticOperation = {
 type ReplaceSemanticOperation = {
   kind: "replaceSemantic";
   target: { type: "definiendum" | "symref"; uri: string };
-  payload: Partial<FtmlNode> & { uri?: string };
+  payload: ReplacePayload;
 };
 
 export type SemanticOperation =
@@ -175,7 +181,7 @@ function removeSemanticNodeWithIndex(
 function replaceSemanticNode(
   node: FtmlTree,
   target: { type: "definiendum" | "symref"; uri: string },
-  payload: ReplaceSemanticOperation["payload"],
+  payload: ReplacePayload,
 ): FtmlTree {
   if (Array.isArray(node)) {
     return node.map((child) =>
@@ -197,23 +203,44 @@ function replaceSemanticNode(
       payload,
     ) as FtmlContent[];
 
+    let symbols = Array.isArray(def.for_symbols)
+      ? def.for_symbols.filter((s) => s !== target.uri)
+      : [];
+
+    if (payload.type === "definiendum" && payload.symdecl && payload.uri) {
+      symbols.push(payload.uri);
+    }
+    {
+      symbols.push(payload.uri);
+    }
+
+    symbols = Array.from(new Set(symbols));
+
     return {
       ...def,
       content: updatedContent,
-      for_symbols: Array.isArray(def.for_symbols)
-        ? def.for_symbols.filter((s) => s !== target.uri)
-        : def.for_symbols,
+      for_symbols: symbols,
     };
   }
 
   if (current.type === target.type && current.uri === target.uri) {
-    return {
-      ...current,
-      uri: payload.uri ?? current.uri,
-      ...(current.type === "definiendum" ? { symdecl: false } : {}),
-    };
-  }
+    if (current.type === "definiendum" && payload.type === "definiendum") {
+      return {
+        ...(current as DefiniendumNode),
+        uri: payload.uri,
+        content: payload.content ?? current.content,
+        symdecl: payload.symdecl,
+      } as DefiniendumNode;
+    }
 
+    if (current.type === "symref" && payload.type === "symref") {
+      return {
+        ...current,
+        uri: payload.uri,
+        content: payload.content ?? current.content,
+      };
+    }
+  }
   const copy: FtmlNode = { ...current };
 
   if (copy.content) {
diff --git a/src/serverFns/definitionAggregate.server.ts b/src/serverFns/definitionAggregate.server.ts
index 0848a1d..5bd3ce6 100644
--- a/src/serverFns/definitionAggregate.server.ts
+++ b/src/serverFns/definitionAggregate.server.ts
@@ -47,3 +47,24 @@ export const getCombinedDefinitionFtml = createServerFn({ method: "GET" })
 
     return combined;
   });
+
+export const getFinalizedLatexById = createServerFn({ method: "GET" })
+  .inputValidator((data: { id: string }) => data)
+  .handler(async ({ data }) => {
+    const record = await prisma.latexTable.findUnique({
+      where: { id: data.id },
+    });
+
+    if (!record || !record.isFinal) {
+      throw new Error("Finalized document not found");
+    }
+
+    return {
+      latex: record.finalLatex,
+      documentId: record.documentId,
+      futureRepo: record.futureRepo,
+      filePath: record.filePath,
+      fileName: record.fileName,
+      language: record.language,
+    };
+  });
diff --git a/src/serverFns/getSymbolUriMap.server.ts b/src/serverFns/getSymbolUriMap.server.ts
new file mode 100644
index 0000000..7944dfc
--- /dev/null
+++ b/src/serverFns/getSymbolUriMap.server.ts
@@ -0,0 +1,64 @@
+import prisma from "@/lib/prisma";
+import {
+  assertFtmlStatement,
+  DefinitionNode,
+  FtmlContent,
+  FtmlNode,
+  isDefiniendumNode,
+  isDefinitionNode,
+  normalizeToRoot,
+} from "@/types/ftml.types";
+import { createServerFn } from "@tanstack/react-start";
+
+function collectDeclaredLabels(
+  node: FtmlNode | FtmlContent,
+  acc: Set<string>,
+): void {
+  if (typeof node === "string") return;
+
+  if (isDefiniendumNode(node) && node.symdecl === true && node.uri) {
+    acc.add(node.uri);
+  }
+
+  if (node.content) {
+    for (const child of node.content) {
+      collectDeclaredLabels(child, acc);
+    }
+  }
+}
+
+export const getDefiningDefinitions = createServerFn({ method: "POST" })
+  .inputValidator((data: { labels: string[] }) => data)
+  .handler(async ({ data }): Promise<Record<string, DefinitionNode>> => {
+    if (!data.labels.length) return {};
+
+    const definitions = await prisma.definition.findMany({
+      where: { status: { not: "DISCARDED" } },
+      select: { statement: true },
+    });
+
+    const result: Record<string, DefinitionNode> = {};
+    const remaining = new Set(data.labels);
+
+    for (const def of definitions) {
+      if (!remaining.size) break;
+
+      const root = normalizeToRoot(assertFtmlStatement(def.statement));
+
+      for (const block of root.content) {
+        if (!isDefinitionNode(block)) continue;
+
+        const declared = new Set<string>();
+        collectDeclaredLabels(block, declared);
+
+        for (const label of declared) {
+          if (remaining.has(label)) {
+            result[label] = block;
+            remaining.delete(label);
+          }
+        }
+      }
+    }
+
+    return result;
+  });
diff --git a/src/serverFns/symbol.server.ts b/src/serverFns/symbol.server.ts
index ba74401..fe6aa38 100644
--- a/src/serverFns/symbol.server.ts
+++ b/src/serverFns/symbol.server.ts
@@ -167,7 +167,6 @@ export const createSymbolDefiniendum = createServerFn({ method: "POST" })
       });
 
       const nextVersion = existing.currentVersion + 1;
-
       const newStatement = JSON.parse(JSON.stringify(unwrapRoot(root)));
 
       await tx.definitionVersion.create({
diff --git a/src/serverFns/updateDefinition.server.ts b/src/serverFns/updateDefinition.server.ts
index d90f269..97b0e17 100644
--- a/src/serverFns/updateDefinition.server.ts
+++ b/src/serverFns/updateDefinition.server.ts
@@ -1,22 +1,9 @@
 import prisma from "@/lib/prisma";
 import { currentUser } from "@/server/auth/currentUser";
-import { transform } from "@/server/parseUri";
-import { FtmlNode, FtmlRoot } from "@/types/ftml.types";
+import { SemanticOperation, transform } from "@/server/parseUri";
+import { FtmlRoot } from "@/types/ftml.types";
 import { createServerFn } from "@tanstack/react-start";
 
-type RemoveSemanticOp = {
-  kind: "removeSemantic";
-  target: { type: "definiendum" | "symref"; uri: string };
-};
-
-type ReplaceSemanticOp = {
-  kind: "replaceSemantic";
-  target: { type: "definiendum" | "symref"; uri: string };
-  payload: FtmlNode;
-};
-
-type SemanticOperation = RemoveSemanticOp | ReplaceSemanticOp;
-
 function assertFtmlRoot(value: unknown): asserts value is FtmlRoot {
   if (!value || typeof value !== "object") {
     throw new Error("Invalid FTML AST");