diff --git a/src/app/editor/page.tsx b/src/app/editor/page.tsx
index 47f976f..e14fd44 100644
--- a/src/app/editor/page.tsx
+++ b/src/app/editor/page.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import type { CSSProperties } from "react";
+import type { CSSProperties, ReactNode } from "react";
 import { useState } from "react";
 import {
   DndContext,
@@ -9,6 +9,7 @@ import {
   useSensor,
   useSensors,
   DragEndEvent,
+  useDroppable,
 } from "@dnd-kit/core";
 import {
   SortableContext,
@@ -17,16 +18,26 @@ import {
 } from "@dnd-kit/sortable";
 import { CSS } from "@dnd-kit/utilities";
 import { useEditorStore } from "@/features/editor/state/editorStore";
-import type { Block } from "@/features/editor/state/editorStore";
+import type {
+  Block,
+  TextBlockProps,
+  ButtonBlockProps,
+  ImageBlockProps,
+  SectionBlockProps,
+} from "@/features/editor/state/editorStore";
 
 export default function EditorPage() {
   const blocks = useEditorStore((state) => state.blocks);
   const selectedBlockId = useEditorStore((state) => state.selectedBlockId);
   const addTextBlock = useEditorStore((state) => state.addTextBlock);
+  const addButtonBlock = useEditorStore((state) => state.addButtonBlock);
+  const addImageBlock = useEditorStore((state) => state.addImageBlock);
+  const addSectionBlock = useEditorStore((state) => state.addSectionBlock);
   const updateBlock = useEditorStore((state) => state.updateBlock);
   const selectBlock = useEditorStore((state) => state.selectBlock);
   const replaceBlocks = useEditorStore((state) => state.replaceBlocks);
   const reorderBlocks = useEditorStore((state) => state.reorderBlocks);
+  const moveBlock = useEditorStore((state) => state.moveBlock);
 
   const [editingBlockId, setEditingBlockId] = useState<string | null>(null);
   const [editingText, setEditingText] = useState("");
@@ -147,9 +158,64 @@ export default function EditorPage() {
   const handleDragEnd = (event: DragEndEvent) => {
     const { active, over } = event;
     if (!over || active.id === over.id) return;
-    reorderBlocks(String(active.id), String(over.id));
+    const activeId = String(active.id);
+    const overId = String(over.id);
+
+    // 컬럼 droppable에 드롭한 경우: 해당 섹션/컬럼으로 이동만 수행한다.
+    if (overId.startsWith("column:")) {
+      const [, sectionId, columnId] = overId.split(":");
+      moveBlock(activeId, sectionId || null, columnId || null);
+      return;
+    }
+
+    const activeBlock = blocks.find((b) => b.id === activeId);
+    const overBlock = blocks.find((b) => b.id === overId);
+
+    if (!activeBlock || !overBlock) {
+      reorderBlocks(activeId, overId);
+      return;
+    }
+
+    const activeSectionId = activeBlock.sectionId ?? null;
+    const activeColumnId = activeBlock.columnId ?? null;
+    const overSectionId = overBlock.sectionId ?? null;
+    const overColumnId = overBlock.columnId ?? null;
+
+    // 같은 섹션/컬럼 내에서는 순서만 변경한다.
+    if (activeSectionId === overSectionId && activeColumnId === overColumnId) {
+      reorderBlocks(activeId, overId);
+      return;
+    }
+
+    // 다른 컬럼/섹션으로 이동: 위치를 변경한 뒤, 블록 기준 드롭이면 순서 재배치까지 진행한다.
+    moveBlock(activeId, overSectionId, overColumnId);
+    reorderBlocks(activeId, overId);
   };
 
+  const rootBlocks = blocks.filter((block) => !block.sectionId);
+
+  const renderBlocks = (targetBlocks: Block[]) =>
+    targetBlocks.map((block) => {
+      const isSelected = block.id === selectedBlockId;
+      const isEditing = block.id === editingBlockId;
+
+      return (
+        <SortableEditorBlock
+          key={block.id}
+          block={block}
+          isSelected={isSelected}
+          isEditing={isEditing}
+          editingText={editingText}
+          startEditing={startEditing}
+          commitEditing={commitEditing}
+          setEditingText={setEditingText}
+          selectBlock={selectBlock}
+          allBlocks={blocks}
+          renderBlocks={renderBlocks}
+        />
+      );
+    });
+
   return (
     <main className="min-h-screen flex flex-col bg-slate-950 text-slate-50">
       <header className="border-b border-slate-800 px-6 py-4 flex items-center justify-between">
@@ -166,6 +232,27 @@ export default function EditorPage() {
           >
             텍스트 블록 추가
           </button>
+          <button
+            type="button"
+            className="w-full rounded border border-slate-700 bg-slate-900 px-3 py-2 text-left text-xs hover:bg-slate-800"
+            onClick={addButtonBlock}
+          >
+            버튼 블록 추가
+          </button>
+          <button
+            type="button"
+            className="w-full rounded border border-slate-700 bg-slate-900 px-3 py-2 text-left text-xs hover:bg-slate-800"
+            onClick={addImageBlock}
+          >
+            이미지 블록 추가
+          </button>
+          <button
+            type="button"
+            className="w-full rounded border border-slate-700 bg-slate-900 px-3 py-2 text-left text-xs hover:bg-slate-800"
+            onClick={addSectionBlock}
+          >
+            섹션 블록 추가
+          </button>
           <p className="text-xs text-slate-500">
             Text / Image / Button / Section 블록을 이 영역에서 추가할 수 있습니다.
           </p>
@@ -188,24 +275,7 @@ export default function EditorPage() {
                 items={blocks.map((b) => b.id)}
                 strategy={verticalListSortingStrategy}
               >
-                {blocks.map((block) => {
-                  const isSelected = block.id === selectedBlockId;
-                  const isEditing = block.id === editingBlockId;
-
-                  return (
-                    <SortableEditorBlock
-                      key={block.id}
-                      block={block}
-                      isSelected={isSelected}
-                      isEditing={isEditing}
-                      editingText={editingText}
-                      startEditing={startEditing}
-                      commitEditing={commitEditing}
-                      setEditingText={setEditingText}
-                      selectBlock={selectBlock}
-                    />
-                  );
-                })}
+                {renderBlocks(rootBlocks)}
               </SortableContext>
             </DndContext>
           )}
@@ -214,66 +284,238 @@ export default function EditorPage() {
           <h2 className="font-medium mb-2">속성 패널</h2>
           {selectedBlockId ? (
             <div className="space-y-3">
-              <div className="space-y-1">
-                <p className="text-xs text-slate-400">선택한 텍스트 블록 내용</p>
-                <textarea
-                  className="w-full min-h-[80px] rounded border border-slate-700 bg-slate-900 px-2 py-1 text-xs outline-none focus:border-sky-500"
-                  aria-label="선택한 텍스트 블록 내용"
-                  value={
-                    blocks.find((b) => b.id === selectedBlockId)?.props.text ?? ""
-                  }
-                  onChange={(e) => {
-                    const value = e.target.value;
-                    updateBlock(selectedBlockId, { text: value });
-                    // 인라인 편집과의 상태 차이를 막기 위해, 현재 인라인 편집 중인 블록이라면 로컬 상태도 동기화한다.
-                    if (editingBlockId === selectedBlockId) {
-                      setEditingText(value);
-                    }
-                  }}
-                />
-              </div>
+              {(() => {
+                const selectedBlock = blocks.find((b) => b.id === selectedBlockId);
+                if (!selectedBlock) return null;
 
-              <div className="space-y-1">
-                <label className="flex flex-col gap-1 text-xs text-slate-400">
-                  <span>정렬</span>
-                  <select
-                    className="rounded border border-slate-700 bg-slate-900 px-2 py-1 text-xs outline-none focus:border-sky-500"
-                    aria-label="정렬"
-                    value={
-                      blocks.find((b) => b.id === selectedBlockId)?.props.align ?? "left"
-                    }
-                    onChange={(e) => {
-                      const value = e.target.value as "left" | "center" | "right";
-                      updateBlock(selectedBlockId, { align: value });
-                    }}
-                  >
-                    <option value="left">왼쪽</option>
-                    <option value="center">가운데</option>
-                    <option value="right">오른쪽</option>
-                  </select>
-                </label>
-              </div>
+                if (selectedBlock.type === "text") {
+                  const textProps = selectedBlock.props as TextBlockProps;
 
-              <div className="space-y-1">
-                <label className="flex flex-col gap-1 text-xs text-slate-400">
-                  <span>글자 크기</span>
-                  <select
-                    className="rounded border border-slate-700 bg-slate-900 px-2 py-1 text-xs outline-none focus:border-sky-500"
-                    aria-label="글자 크기"
-                    value={
-                      blocks.find((b) => b.id === selectedBlockId)?.props.size ?? "base"
-                    }
-                    onChange={(e) => {
-                      const value = e.target.value as "sm" | "base" | "lg";
-                      updateBlock(selectedBlockId, { size: value });
-                    }}
-                  >
-                    <option value="sm">작게</option>
-                    <option value="base">보통</option>
-                    <option value="lg">크게</option>
-                  </select>
-                </label>
-              </div>
+                  return (
+                    <>
+                      <div className="space-y-1">
+                        <p className="text-xs text-slate-400">선택한 텍스트 블록 내용</p>
+                        <textarea
+                          className="w-full min-h-[80px] rounded border border-slate-700 bg-slate-900 px-2 py-1 text-xs outline-none focus:border-sky-500"
+                          aria-label="선택한 텍스트 블록 내용"
+                          value={textProps.text}
+                          onChange={(e) => {
+                            const value = e.target.value;
+                            updateBlock(selectedBlockId, { text: value });
+                            if (editingBlockId === selectedBlockId) {
+                              setEditingText(value);
+                            }
+                          }}
+                        />
+                      </div>
+
+                      <div className="space-y-1">
+                        <label className="flex flex-col gap-1 text-xs text-slate-400">
+                          <span>정렬</span>
+                          <select
+                            className="rounded border border-slate-700 bg-slate-900 px-2 py-1 text-xs outline-none focus:border-sky-500"
+                            aria-label="정렬"
+                            value={textProps.align}
+                            onChange={(e) => {
+                              const value = e.target.value as "left" | "center" | "right";
+                              updateBlock(selectedBlockId, { align: value });
+                            }}
+                          >
+                            <option value="left">왼쪽</option>
+                            <option value="center">가운데</option>
+                            <option value="right">오른쪽</option>
+                          </select>
+                        </label>
+                      </div>
+
+                      <div className="space-y-1">
+                        <label className="flex flex-col gap-1 text-xs text-slate-400">
+                          <span>글자 크기</span>
+                          <select
+                            className="rounded border border-slate-700 bg-slate-900 px-2 py-1 text-xs outline-none focus:border-sky-500"
+                            aria-label="글자 크기"
+                            value={textProps.size}
+                            onChange={(e) => {
+                              const value = e.target.value as "sm" | "base" | "lg";
+                              updateBlock(selectedBlockId, { size: value });
+                            }}
+                          >
+                            <option value="sm">작게</option>
+                            <option value="base">보통</option>
+                            <option value="lg">크게</option>
+                          </select>
+                        </label>
+                      </div>
+                    </>
+                  );
+                }
+
+                if (selectedBlock.type === "image") {
+                  const imageProps = selectedBlock.props as ImageBlockProps;
+
+                  return (
+                    <>
+                      <div className="space-y-1">
+                        <label className="flex flex-col gap-1 text-xs text-slate-400">
+                          <span>이미지 URL</span>
+                          <input
+                            className="w-full rounded border border-slate-700 bg-slate-900 px-2 py-1 text-xs outline-none focus:border-sky-500"
+                            aria-label="이미지 URL"
+                            value={imageProps.src}
+                            onChange={(e) => {
+                              updateBlock(selectedBlockId, { src: e.target.value } as any);
+                            }}
+                          />
+                        </label>
+                      </div>
+                      <div className="space-y-1">
+                        <label className="flex flex-col gap-1 text-xs text-slate-400">
+                          <span>대체 텍스트</span>
+                          <input
+                            className="w-full rounded border border-slate-700 bg-slate-900 px-2 py-1 text-xs outline-none focus:border-sky-500"
+                            aria-label="대체 텍스트"
+                            value={imageProps.alt}
+                            onChange={(e) => {
+                              updateBlock(selectedBlockId, { alt: e.target.value } as any);
+                            }}
+                          />
+                        </label>
+                      </div>
+                    </>
+                  );
+                }
+
+                if (selectedBlock.type === "section") {
+                  const sectionProps = selectedBlock.props as SectionBlockProps;
+
+                  return (
+                    <>
+                      <div className="space-y-1">
+                        <label className="flex flex-col gap-1 text-xs text-slate-400">
+                          <span>레이아웃</span>
+                          <select
+                            className="rounded border border-slate-700 bg-slate-900 px-2 py-1 text-xs outline-none focus:border-sky-500"
+                            aria-label="섹션 레이아웃"
+                            value={(() => {
+                              const cols = sectionProps.columns ?? [];
+                              if (cols.length === 1 && cols[0].span === 12) return "1col";
+                              if (cols.length === 2 && cols[0].span === 6 && cols[1].span === 6) return "2col";
+                              if (
+                                cols.length === 3 &&
+                                cols[0].span === 4 &&
+                                cols[1].span === 4 &&
+                                cols[2].span === 4
+                              )
+                                return "3col";
+                              return "custom";
+                            })()}
+                            onChange={(e) => {
+                              const preset = e.target.value;
+                              if (preset === "custom") return;
+
+                              const cols =
+                                preset === "1col"
+                                  ? [{ id: `${selectedBlock.id}_col_1`, span: 12 }]
+                                  : preset === "2col"
+                                  ? [
+                                      { id: `${selectedBlock.id}_col_1`, span: 6 },
+                                      { id: `${selectedBlock.id}_col_2`, span: 6 },
+                                    ]
+                                  : [
+                                      { id: `${selectedBlock.id}_col_1`, span: 4 },
+                                      { id: `${selectedBlock.id}_col_2`, span: 4 },
+                                      { id: `${selectedBlock.id}_col_3`, span: 4 },
+                                    ];
+
+                              updateBlock(selectedBlockId, { columns: cols } as any);
+                            }}
+                          >
+                            <option value="1col">1열 (100%)</option>
+                            <option value="2col">2열 (50 / 50)</option>
+                            <option value="3col">3열 (33 / 33 / 33)</option>
+                            <option value="custom" disabled>
+                              사용자 정의
+                            </option>
+                          </select>
+                        </label>
+                      </div>
+                      <div className="space-y-1">
+                        <label className="flex flex-col gap-1 text-xs text-slate-400">
+                          <span>배경색</span>
+                          <select
+                            className="rounded border border-slate-700 bg-slate-900 px-2 py-1 text-xs outline-none focus:border-sky-500"
+                            aria-label="섹션 배경색"
+                            value={sectionProps.background}
+                            onChange={(e) => {
+                              const value = e.target.value as SectionBlockProps["background"];
+                              updateBlock(selectedBlockId, { background: value } as any);
+                            }}
+                          >
+                            <option value="default">기본</option>
+                            <option value="muted">Muted</option>
+                            <option value="primary">Primary</option>
+                          </select>
+                        </label>
+                      </div>
+                      <div className="space-y-1">
+                        <label className="flex flex-col gap-1 text-xs text-slate-400">
+                          <span>세로 패딩</span>
+                          <select
+                            className="rounded border border-slate-700 bg-slate-900 px-2 py-1 text-xs outline-none focus:border-sky-500"
+                            aria-label="섹션 세로 패딩"
+                            value={sectionProps.paddingY}
+                            onChange={(e) => {
+                              const value = e.target.value as SectionBlockProps["paddingY"];
+                              updateBlock(selectedBlockId, { paddingY: value } as any);
+                            }}
+                          >
+                            <option value="sm">작게</option>
+                            <option value="md">보통</option>
+                            <option value="lg">크게</option>
+                          </select>
+                        </label>
+                      </div>
+                    </>
+                  );
+                }
+
+                if (selectedBlock.type === "button") {
+                  const buttonProps = selectedBlock.props as ButtonBlockProps;
+
+                  return (
+                    <>
+                      <div className="space-y-1">
+                        <label className="flex flex-col gap-1 text-xs text-slate-400">
+                          <span>버튼 텍스트</span>
+                          <input
+                            className="w-full rounded border border-slate-700 bg-slate-900 px-2 py-1 text-xs outline-none focus:border-sky-500"
+                            aria-label="버튼 텍스트"
+                            value={buttonProps.label}
+                            onChange={(e) => {
+                              updateBlock(selectedBlockId, { label: e.target.value } as any);
+                            }}
+                          />
+                        </label>
+                      </div>
+                      <div className="space-y-1">
+                        <label className="flex flex-col gap-1 text-xs text-slate-400">
+                          <span>버튼 링크</span>
+                          <input
+                            className="w-full rounded border border-slate-700 bg-slate-900 px-2 py-1 text-xs outline-none focus:border-sky-500"
+                            aria-label="버튼 링크"
+                            value={buttonProps.href}
+                            onChange={(e) => {
+                              updateBlock(selectedBlockId, { href: e.target.value } as any);
+                            }}
+                          />
+                        </label>
+                      </div>
+                    </>
+                  );
+                }
+
+                return null;
+              })()}
             </div>
           ) : (
             <p className="text-xs text-slate-500">
@@ -395,6 +637,8 @@ interface SortableEditorBlockProps {
   commitEditing: () => void;
   setEditingText: (value: string) => void;
   selectBlock: (id: string) => void;
+  allBlocks: Block[];
+  renderBlocks: (targetBlocks: Block[]) => ReactNode;
 }
 
 function SortableEditorBlock({
@@ -406,6 +650,8 @@ function SortableEditorBlock({
   commitEditing,
   setEditingText,
   selectBlock,
+  allBlocks,
+  renderBlocks,
 }: SortableEditorBlockProps) {
   const { attributes, listeners, setNodeRef, transform, transition } = useSortable({
     id: block.id,
@@ -416,19 +662,36 @@ function SortableEditorBlock({
     transition,
   };
 
-  const alignClass =
-    block.props.align === "center"
-      ? "text-center"
-      : block.props.align === "right"
-      ? "text-right"
-      : "text-left";
+  let alignClass = "";
+  let sizeClass = "";
 
-  const sizeClass =
-    block.props.size === "sm"
-      ? "text-sm"
-      : block.props.size === "lg"
-      ? "text-lg"
-      : "text-base";
+  if (block.type === "text") {
+    const textProps = block.props as TextBlockProps;
+    alignClass =
+      textProps.align === "center"
+        ? "text-center"
+        : textProps.align === "right"
+        ? "text-right"
+        : "text-left";
+
+    sizeClass =
+      textProps.size === "sm"
+        ? "text-sm"
+        : textProps.size === "lg"
+        ? "text-lg"
+        : "text-base";
+  } else if (block.type === "button") {
+    // 버튼 블록은 기본 텍스트 스타일만 적용
+    alignClass = "text-left";
+    sizeClass = "text-base";
+  } else if (block.type === "image") {
+    alignClass = "text-left";
+    sizeClass = "text-base";
+  } else {
+    // 섹션 블록: 텍스트 크기 대신 섹션 자체에 패딩/배경을 입히므로 텍스트 클래스는 기본값만
+    alignClass = "text-left";
+    sizeClass = "text-base";
+  }
 
   return (
     <div
@@ -441,7 +704,12 @@ function SortableEditorBlock({
         isSelected ? "border-sky-500 bg-slate-900/80" : "border-slate-700 bg-slate-900"
       }`}
       onClick={() => selectBlock(block.id)}
-      onDoubleClick={() => startEditing(block.id, block.props.text)}
+      onDoubleClick={() => {
+        if (block.type === "text") {
+          const textProps = block.props as TextBlockProps;
+          startEditing(block.id, textProps.text);
+        }
+      }}
     >
       <div className="flex items-start gap-2">
         <button
@@ -454,27 +722,146 @@ function SortableEditorBlock({
           ≡
         </button>
         <div className="flex-1">
-          {isEditing ? (
-            <textarea
-              className="w-full bg-transparent outline-none resize-none text-sm"
-              aria-label="텍스트 블록 내용 편집"
-              value={editingText}
-              onChange={(e) => setEditingText(e.target.value)}
-              onBlur={commitEditing}
-              onKeyDown={(e) => {
-                if (e.key === "Enter" && !e.shiftKey) {
-                  e.preventDefault();
-                  commitEditing();
-                }
-              }}
-              rows={1}
-              autoFocus
-            />
-          ) : (
-            <div>{block.props.text}</div>
+          {block.type === "text" && (
+            isEditing ? (
+              <textarea
+                className="w-full bg-transparent outline-none resize-none text-sm"
+                aria-label="텍스트 블록 내용 편집"
+                value={editingText}
+                onChange={(e) => setEditingText(e.target.value)}
+                onBlur={commitEditing}
+                onKeyDown={(e) => {
+                  if (e.key === "Enter" && !e.shiftKey) {
+                    e.preventDefault();
+                    commitEditing();
+                  }
+                }}
+                rows={1}
+                autoFocus
+              />
+            ) : (
+              <div>{(block.props as TextBlockProps).text}</div>
+            )
           )}
+          {block.type === "button" && (() => {
+            const buttonProps = block.props as ButtonBlockProps;
+            return (
+              <button
+                type="button"
+                className="inline-flex items-center justify-center rounded border border-slate-600 bg-slate-800 px-3 py-1 text-xs font-medium text-slate-50 hover:bg-slate-700"
+                aria-label={buttonProps.label}
+                onClick={(e) => {
+                  // 에디터 내 버튼 클릭은 선택만 유지하고 실제 이동은 막는다.
+                  e.stopPropagation();
+                }}
+              >
+                {buttonProps.label}
+              </button>
+            );
+          })()}
+          {block.type === "image" && (() => {
+            const imageProps = block.props as ImageBlockProps;
+            const hasSrc = imageProps.src.trim().length > 0;
+            return (
+              <div className="w-full border border-dashed border-slate-700 bg-slate-900/40 rounded flex items-center justify-center overflow-hidden">
+                {hasSrc ? (
+                  // eslint-disable-next-line @next/next/no-img-element
+                  <img
+                    src={imageProps.src}
+                    alt={imageProps.alt}
+                    className="max-w-full h-auto object-contain"
+                  />
+                ) : (
+                  <span className="text-[10px] text-slate-500 px-2 py-4">
+                    이미지 URL을 속성 패널에서 입력하세요.
+                  </span>
+                )}
+              </div>
+            );
+          })()}
+          {block.type === "section" && (() => {
+            const sectionProps = block.props as SectionBlockProps;
+
+            const bgClass =
+              sectionProps.background === "muted"
+                ? "bg-slate-950/40"
+                : sectionProps.background === "primary"
+                ? "bg-sky-950/40 border-sky-900/60"
+                : "bg-slate-900/60";
+
+            const pyClass =
+              sectionProps.paddingY === "sm"
+                ? "py-4"
+                : sectionProps.paddingY === "lg"
+                ? "py-10"
+                : "py-6";
+
+            const columns = sectionProps.columns && sectionProps.columns.length > 0
+              ? sectionProps.columns
+              : [{ id: `${block.id}_col_fallback`, span: 12 }];
+
+            return (
+              <div className={`w-full ${bgClass} ${pyClass} rounded border border-dashed border-slate-700`}
+              >
+                <div className="flex gap-3">
+                  {columns.map((col) => {
+                    const basis = `${(col.span / 12) * 100}%`;
+                    const columnBlocks = allBlocks.filter(
+                      (b) => b.sectionId === block.id && b.columnId === col.id,
+                    );
+                    const droppableId = `column:${block.id}:${col.id}`;
+                    return (
+                      <ColumnDroppable
+                        key={col.id}
+                        id={droppableId}
+                        sectionId={block.id}
+                        columnId={col.id}
+                      >
+                        <div
+                          className="border border-slate-800/80 bg-slate-950/40 rounded flex flex-col gap-2 items-stretch justify-start px-2 py-2"
+                          style={{ flexBasis: basis }}
+                        >
+                          {columnBlocks.length === 0 ? (
+                            <span className="text-[11px] text-slate-500 px-2 text-center">
+                              컬럼 영역 (span {col.span}/12)
+                            </span>
+                          ) : (
+                            <div className="flex flex-col gap-2">
+                              {renderBlocks(columnBlocks)}
+                            </div>
+                          )}
+                        </div>
+                      </ColumnDroppable>
+                    );
+                  })}
+                </div>
+              </div>
+            );
+          })()}
         </div>
       </div>
     </div>
   );
 }
+
+interface ColumnDroppableProps {
+  id: string;
+  sectionId: string;
+  columnId: string;
+  children: ReactNode;
+}
+
+function ColumnDroppable({ id, sectionId, columnId, children }: ColumnDroppableProps) {
+  const { setNodeRef } = useDroppable({ id });
+
+  return (
+    <div
+      ref={setNodeRef}
+      data-section-id={sectionId}
+      data-column-id={columnId}
+      className="flex-1"
+    >
+      {children}
+    </div>
+  );
+}
diff --git a/src/features/editor/state/editorStore.ts b/src/features/editor/state/editorStore.ts
index 2681826..5bca76d 100644
--- a/src/features/editor/state/editorStore.ts
+++ b/src/features/editor/state/editorStore.ts
@@ -1,8 +1,8 @@
 import { createStore } from "zustand";
 import { create } from "zustand";
 
-// 블록 타입 정의: 1단계에서는 텍스트 블록만 사용
-export type BlockType = "text"; // 이후 image/button/section 으로 확장 예정
+// 블록 타입 정의: 텍스트/버튼/이미지/섹션 블록
+export type BlockType = "text" | "button" | "image" | "section";
 
 // 텍스트 블록 속성
 export interface TextBlockProps {
@@ -13,11 +13,38 @@ export interface TextBlockProps {
   size: "sm" | "base" | "lg";
 }
 
+// 버튼 블록 속성
+export interface ButtonBlockProps {
+  label: string;
+  href: string;
+  // TODO: variant, size 등은 추후 확장
+}
+
+// 이미지 블록 속성
+export interface ImageBlockProps {
+  src: string;
+  alt: string;
+}
+
+// 섹션 블록 속성
+export interface SectionBlockProps {
+  background: "default" | "muted" | "primary";
+  paddingY: "sm" | "md" | "lg";
+  // 레이아웃 컬럼 정의 (12 그리드 기준 span)
+  columns: Array<{
+    id: string;
+    span: number;
+  }>;
+}
+
 // 공통 블록 모델
 export interface Block {
   id: string;
   type: BlockType;
-  props: TextBlockProps;
+  props: TextBlockProps | ButtonBlockProps | ImageBlockProps | SectionBlockProps;
+  // 레이아웃 트리 상 위치 정보 (루트 텍스트/버튼/이미지 블록은 null)
+  sectionId?: string | null;
+  columnId?: string | null;
 }
 
 // 에디터 상태 인터페이스
@@ -25,10 +52,14 @@ export interface EditorState {
   blocks: Block[];
   selectedBlockId: string | null;
   addTextBlock: () => void;
-  updateBlock: (id: string, partial: Partial<TextBlockProps>) => void;
+  addButtonBlock: () => void;
+  addImageBlock: () => void;
+  addSectionBlock: () => void;
+  updateBlock: (id: string, partial: Partial<TextBlockProps & ButtonBlockProps>) => void;
   selectBlock: (id: string | null) => void;
   replaceBlocks: (blocks: Block[]) => void;
   reorderBlocks: (activeId: string, overId: string) => void;
+  moveBlock: (id: string, sectionId: string | null, columnId: string | null) => void;
 }
 
 // 간단한 ID 생성기 (추후 uuid 라이브러리로 교체 가능)
@@ -44,6 +75,25 @@ const createEditorState = (set: any, get: any): EditorState => ({
     // 텍스트 블록 추가: 기본 텍스트와 함께 생성 후 선택 상태로 만든다
     addTextBlock: () => {
       const id = createId();
+
+      const { selectedBlockId, blocks } = get();
+      let sectionId: string | null = null;
+      let columnId: string | null = null;
+
+      if (selectedBlockId) {
+        const target = blocks.find((b: Block) => b.id === selectedBlockId);
+        if (target) {
+          if (target.type === "section") {
+            const sProps = target.props as SectionBlockProps;
+            sectionId = target.id;
+            columnId = sProps.columns?.[0]?.id ?? null;
+          } else {
+            sectionId = (target as any).sectionId ?? null;
+            columnId = (target as any).columnId ?? null;
+          }
+        }
+      }
+
       const newBlock: Block = {
         id,
         type: "text",
@@ -52,6 +102,8 @@ const createEditorState = (set: any, get: any): EditorState => ({
           align: "left",
           size: "base",
         },
+        sectionId,
+        columnId,
       };
 
       set((state: EditorState) => ({
@@ -60,7 +112,110 @@ const createEditorState = (set: any, get: any): EditorState => ({
       }));
     },
 
-    // 특정 블록의 텍스트 속성을 부분 업데이트
+    // 이미지 블록 추가: 기본 플레이스홀더와 함께 생성 후 선택 상태로 만든다
+    addImageBlock: () => {
+      const id = createId();
+
+      const { selectedBlockId, blocks } = get();
+      let sectionId: string | null = null;
+      let columnId: string | null = null;
+
+      if (selectedBlockId) {
+        const target = blocks.find((b: Block) => b.id === selectedBlockId);
+        if (target) {
+          if (target.type === "section") {
+            const sProps = target.props as SectionBlockProps;
+            sectionId = target.id;
+            columnId = sProps.columns?.[0]?.id ?? null;
+          } else {
+            sectionId = (target as any).sectionId ?? null;
+            columnId = (target as any).columnId ?? null;
+          }
+        }
+      }
+
+      const newBlock: Block = {
+        id,
+        type: "image",
+        props: {
+          src: "",
+          alt: "이미지 설명",
+        },
+        sectionId,
+        columnId,
+      };
+
+      set((state: EditorState) => ({
+        blocks: [...state.blocks, newBlock],
+        selectedBlockId: id,
+      }));
+    },
+
+    // 섹션 블록 추가: 배경/패딩 기본값과 함께 생성 후 선택 상태로 만든다
+    addSectionBlock: () => {
+      const id = createId();
+      const newBlock: Block = {
+        id,
+        type: "section",
+        props: {
+          background: "default",
+          paddingY: "md",
+          columns: [
+            {
+              id: `${id}_col_1`,
+              span: 12,
+            },
+          ],
+        },
+        sectionId: null,
+        columnId: null,
+      };
+
+      set((state: EditorState) => ({
+        blocks: [...state.blocks, newBlock],
+        selectedBlockId: id,
+      }));
+    },
+
+    // 버튼 블록 추가: 기본 라벨/링크와 함께 생성 후 선택 상태로 만든다
+    addButtonBlock: () => {
+      const id = createId();
+
+      const { selectedBlockId, blocks } = get();
+      let sectionId: string | null = null;
+      let columnId: string | null = null;
+
+      if (selectedBlockId) {
+        const target = blocks.find((b: Block) => b.id === selectedBlockId);
+        if (target) {
+          if (target.type === "section") {
+            const sProps = target.props as SectionBlockProps;
+            sectionId = target.id;
+            columnId = sProps.columns?.[0]?.id ?? null;
+          } else {
+            sectionId = (target as any).sectionId ?? null;
+            columnId = (target as any).columnId ?? null;
+          }
+        }
+      }
+      const newBlock: Block = {
+        id,
+        type: "button",
+        props: {
+          label: "버튼",
+          href: "#",
+        },
+        sectionId,
+        columnId,
+      };
+
+      set((state: EditorState) => ({
+        blocks: [...state.blocks, newBlock],
+        selectedBlockId: id,
+      }));
+    },
+
+    // 특정 블록의 속성을 부분 업데이트 (텍스트/버튼 공통 사용)
     updateBlock: (id, partial) => {
       set((state: EditorState) => ({
         blocks: state.blocks.map((block: Block) =>
@@ -109,6 +264,19 @@ const createEditorState = (set: any, get: any): EditorState => ({
         return { blocks: updated };
       });
     },
+    moveBlock: (id, sectionId, columnId) => {
+      set((state: EditorState) => ({
+        blocks: state.blocks.map((block: Block) =>
+          block.id === id
+            ? {
+                ...block,
+                sectionId,
+                columnId,
+              }
+            : block,
+        ),
+      }));
+    },
   });
 
 // React 컴포넌트에서 사용하는 전역 훅 스토어
diff --git a/tests/e2e/editor.spec.ts b/tests/e2e/editor.spec.ts
index 0143114..0db44e5 100644
--- a/tests/e2e/editor.spec.ts
+++ b/tests/e2e/editor.spec.ts
@@ -229,3 +229,65 @@ test("블록 드래그앤드롭으로 순서를 변경할 수 있어야 한다",
   await expect(reorderedBlocks.nth(0)).toContainText("블록 B");
   await expect(reorderedBlocks.nth(1)).toContainText("블록 A");
 });
+
+test("버튼 블록을 추가하고 라벨과 링크를 수정할 수 있어야 한다", async ({ page }) => {
+  await page.goto("/editor");
+
+  const canvas = page.getByTestId("editor-canvas");
+
+  // 버튼 블록을 추가한다.
+  await page.getByRole("button", { name: "버튼 블록 추가" }).click();
+
+  // 캔버스에 기본 버튼이 렌더되어야 한다.
+  const button = canvas.getByRole("button", { name: "버튼" });
+  await expect(button).toBeVisible();
+
+  // 속성 패널에서 버튼 텍스트와 링크를 수정한다.
+  const labelInput = page.getByRole("textbox", { name: "버튼 텍스트" });
+  const hrefInput = page.getByRole("textbox", { name: "버튼 링크" });
+
+  await labelInput.fill("자세히 보기");
+  await hrefInput.fill("https://example.com");
+
+  // 캔버스의 버튼 텍스트가 변경되어야 한다.
+  const updatedButton = canvas.getByRole("button", { name: "자세히 보기" });
+  await expect(updatedButton).toBeVisible();
+});
+
+test("2컬럼 섹션에서 블록을 다른 컬럼 영역으로 드래그하면 컬럼이 변경되어야 한다", async ({ page }) => {
+  await page.goto("/editor");
+
+  const canvas = page.getByTestId("editor-canvas");
+
+  // 섹션을 하나 추가하고 레이아웃을 2컬럼으로 변경한다.
+  await page.getByRole("button", { name: "섹션 블록 추가" }).click();
+
+  // 섹션을 선택한다 (캔버스 첫 블록).
+  const sectionBlock = canvas.getByTestId("editor-block").nth(0);
+  await sectionBlock.click();
+
+  const layoutSelect = page.getByRole("combobox", { name: "섹션 레이아웃" });
+  await layoutSelect.selectOption("2col");
+
+  // 왼쪽 컬럼에 텍스트 블록을 하나 추가한다.
+  await page.getByRole("button", { name: "텍스트 블록 추가" }).click();
+
+  const leftColumn = canvas.locator('[data-section-id][data-column-id]').nth(0);
+  const rightColumn = canvas.locator('[data-section-id][data-column-id]').nth(1);
+
+  // 왼쪽 컬럼 안에 텍스트 블록이 존재하는지 확인한다.
+  const leftBlocks = leftColumn.getByTestId("editor-block");
+  await expect(leftBlocks).toHaveCount(1);
+
+  // 왼쪽 컬럼의 첫 블록을 오른쪽 컬럼 droppable 영역으로 드래그한다.
+  const leftBlock = leftBlocks.nth(0);
+  const handle = leftBlock.getByRole("button", { name: "블록 드래그 핸들" });
+  await handle.dragTo(rightColumn);
+
+  // 드래그 이후, 오른쪽 컬럼 안에 블록이 존재해야 하고 왼쪽 컬럼은 비어 있어야 한다.
+  const rightBlocks = rightColumn.getByTestId("editor-block");
+  await expect(rightBlocks).toHaveCount(1);
+
+  // 왼쪽 컬럼에는 더 이상 블록이 없어야 한다.
+  await expect(leftColumn.getByTestId("editor-block")).toHaveCount(0);
+});
diff --git a/tests/unit/editorStore.spec.ts b/tests/unit/editorStore.spec.ts
index b23726e..9100755 100644
--- a/tests/unit/editorStore.spec.ts
+++ b/tests/unit/editorStore.spec.ts
@@ -1,5 +1,9 @@
 import { describe, it, expect } from "vitest";
-import { createEditorStore } from "@/features/editor/state/editorStore";
+import {
+  createEditorStore,
+  type TextBlockProps,
+  type ButtonBlockProps,
+} from "@/features/editor/state/editorStore";
 
 // 에디터 상태 스토어에 대한 첫 TDD: 텍스트 블록 추가
 
@@ -13,7 +17,8 @@ describe("editorStore", () => {
 
     expect(blocks).toHaveLength(1);
     expect(blocks[0].type).toBe("text");
-    expect(blocks[0].props.text).toBe("새 텍스트");
+    const textProps = blocks[0].props as TextBlockProps;
+    expect(textProps.text).toBe("새 텍스트");
     expect(selectedBlockId).toBe(blocks[0].id);
   });
 
@@ -39,6 +44,134 @@ describe("editorStore", () => {
     blocks = store.getState().blocks;
 
     expect(blocks.map((b) => b.id)).toEqual([bId, aId, cId]);
-    expect(blocks.map((b) => b.props.text)).toEqual(["블록 B", "블록 A", "블록 C"]);
+    expect(blocks.map((b) => (b.props as TextBlockProps).text)).toEqual([
+      "블록 B",
+      "블록 A",
+      "블록 C",
+    ]);
+  });
+
+  it("버튼 블록을 추가하고 라벨/링크를 업데이트할 수 있어야 한다", () => {
+    const store = createEditorStore();
+
+    // 텍스트 블록 외에 버튼 블록을 추가하는 액션을 호출한다고 가정한다.
+    store.getState().addButtonBlock();
+
+    const { blocks, selectedBlockId } = store.getState();
+
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].type).toBe("button");
+    const buttonProps = blocks[0].props as ButtonBlockProps;
+    expect(buttonProps.label).toBe("버튼");
+    expect(buttonProps.href).toBe("#");
+
+    // 버튼 라벨과 링크를 업데이트한다.
+    store.getState().updateBlock(blocks[0].id, {
+      label: "자세히 보기",
+      href: "https://example.com",
+    } as any);
+
+    const { blocks: updatedBlocks } = store.getState();
+    const updatedButtonProps = updatedBlocks[0].props as ButtonBlockProps;
+    expect(updatedButtonProps.label).toBe("자세히 보기");
+    expect(updatedButtonProps.href).toBe("https://example.com");
+    expect(selectedBlockId).toBe(updatedBlocks[0].id);
+  });
+
+  it("섹션이 선택된 상태에서 텍스트 블록을 추가하면 해당 섹션의 첫 컬럼에 배치되어야 한다", () => {
+    const store = createEditorStore();
+
+    // 섹션 블록을 하나 추가하고 기본 1컬럼 레이아웃을 사용한다.
+    store.getState().addSectionBlock();
+
+    const { blocks: afterSection } = store.getState();
+    expect(afterSection).toHaveLength(1);
+    const sectionBlock = afterSection[0];
+    expect(sectionBlock.type).toBe("section");
+
+    const sectionProps = sectionBlock.props as any;
+    expect(Array.isArray(sectionProps.columns)).toBe(true);
+    expect(sectionProps.columns.length).toBeGreaterThan(0);
+
+    // 섹션을 선택한 후 텍스트 블록을 추가한다.
+    store.getState().selectBlock(sectionBlock.id);
+    store.getState().addTextBlock();
+
+    const { blocks: finalBlocks } = store.getState();
+    expect(finalBlocks).toHaveLength(2);
+
+    const textBlock = finalBlocks.find((b) => b.type === "text")!;
+
+    // 새 텍스트 블록의 sectionId/columnId가 선택된 섹션과 첫 컬럼을 가리켜야 한다.
+    expect((textBlock as any).sectionId).toBe(sectionBlock.id);
+    expect((textBlock as any).columnId).toBe(sectionProps.columns[0].id);
+  });
+
+  it("블록이 선택된 상태에서 새 텍스트 블록을 추가하면 동일한 섹션/컬럼에 배치되어야 한다", () => {
+    const store = createEditorStore();
+
+    // 섹션 + 텍스트 블록을 만든다.
+    store.getState().addSectionBlock();
+    const { blocks: afterSection } = store.getState();
+    const sectionBlock = afterSection[0];
+    const sectionProps = sectionBlock.props as any;
+
+    store.getState().selectBlock(sectionBlock.id);
+    store.getState().addTextBlock();
+
+    let { blocks } = store.getState();
+    const firstText = blocks.find((b) => b.type === "text")!;
+
+    // 첫 텍스트 블록의 위치를 기준으로 한다.
+    store.getState().selectBlock(firstText.id);
+    store.getState().addTextBlock();
+
+    blocks = store.getState().blocks;
+    const textBlocks = blocks.filter((b) => b.type === "text");
+    expect(textBlocks).toHaveLength(2);
+
+    const [t1, t2] = textBlocks as any[];
+
+    // 두 번째 텍스트 블록도 같은 섹션/컬럼에 있어야 한다.
+    expect(t1.sectionId).toBe(sectionBlock.id);
+    expect(t2.sectionId).toBe(sectionBlock.id);
+    expect(t1.columnId).toBe(sectionProps.columns[0].id);
+    expect(t2.columnId).toBe(sectionProps.columns[0].id);
+  });
+
+  it("moveBlock 호출 시 블록의 sectionId/columnId가 변경되어야 한다", () => {
+    const store = createEditorStore();
+
+    // 섹션 + 텍스트 블록 1개를 만든다.
+    store.getState().addSectionBlock();
+    const { blocks: afterSection } = store.getState();
+    const sectionBlock = afterSection[0];
+    const sectionProps = sectionBlock.props as any;
+
+    store.getState().selectBlock(sectionBlock.id);
+    store.getState().addTextBlock();
+
+    let { blocks } = store.getState();
+    const textBlock = blocks.find((b) => b.type === "text") as any;
+
+    // 초기 위치는 섹션의 첫 컬럼이어야 한다.
+    expect(textBlock.sectionId).toBe(sectionBlock.id);
+    expect(textBlock.columnId).toBe(sectionProps.columns[0].id);
+
+    // 섹션 레이아웃을 2컬럼으로 바꾸고 두 번째 컬럼으로 이동시킨다.
+    const updatedColumns = [
+      { id: `${sectionBlock.id}_col_1`, span: 6 },
+      { id: `${sectionBlock.id}_col_2`, span: 6 },
+    ];
+
+    store.getState().updateBlock(sectionBlock.id, { columns: updatedColumns } as any);
+
+    store.getState().moveBlock(textBlock.id, sectionBlock.id, updatedColumns[1].id);
+
+    blocks = store.getState().blocks;
+    const moved = blocks.find((b) => b.id === textBlock.id) as any;
+
+    expect(moved.sectionId).toBe(sectionBlock.id);
+    expect(moved.columnId).toBe(updatedColumns[1].id);
   });
 });