diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 2905dc9d6..8515fee5c 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -17,7 +17,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
         with:
-          node-version: 20
+          node-version: 24
       - run: yarn --frozen-lockfile
       - run: yarn ci
       - run: yarn build
diff --git a/package.json b/package.json
index 32ae48b27..9923e0c4a 100755
--- a/package.json
+++ b/package.json
@@ -78,7 +78,7 @@
     "jest-transform-css": "^6.0.1",
     "npm-run-all": "^4.1.5",
     "postcss": "^8.3.6",
-    "prettier": "^2.3.2",
+    "prettier": "^3.6.2",
     "prop-types": "^15.8.1",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
diff --git a/src/ActiveCell.tsx b/src/ActiveCell.tsx
index d077c1439..cf716760b 100644
--- a/src/ActiveCell.tsx
+++ b/src/ActiveCell.tsx
@@ -16,20 +16,25 @@ const ActiveCell: React.FC<Props> = (props) => {
   const rootRef = React.useRef<HTMLDivElement>(null);
 
   const dispatch = useDispatch();
+
   const setCellData = React.useCallback(
     (active: Point.Point, data: Types.CellBase) =>
       dispatch(Actions.setCellData(active, data)),
     [dispatch]
   );
+
   const edit = React.useCallback(() => dispatch(Actions.edit()), [dispatch]);
+
   const commit = React.useCallback(
     (changes: Types.CommitChanges<Types.CellBase>) =>
       dispatch(Actions.commit(changes)),
     [dispatch]
   );
+
   const view = React.useCallback(() => {
     dispatch(Actions.view());
   }, [dispatch]);
+
   const active = useSelector((state) => state.active);
   const mode = useSelector((state) => state.mode);
   const cell = useSelector((state) =>
diff --git a/src/AutoFillHandle.tsx b/src/AutoFillHandle.tsx
new file mode 100644
index 000000000..c354f39b2
--- /dev/null
+++ b/src/AutoFillHandle.tsx
@@ -0,0 +1,42 @@
+import * as React from "react";
+import * as Actions from "./actions";
+import useDispatch from "./use-dispatch";
+
+const AutoFillHandle: React.FC = () => {
+  const dispatch = useDispatch();
+
+  const autoFillStart = React.useCallback(() => {
+    dispatch(Actions.autoFillStart());
+  }, [dispatch]);
+
+  const autoFillEnd = React.useCallback(() => {
+    dispatch(Actions.autoFillEnd());
+  }, [dispatch]);
+
+  const handleMouseDown = React.useCallback(
+    (event: React.MouseEvent) => {
+      event.stopPropagation();
+      event.preventDefault();
+
+      autoFillStart();
+
+      const handleMouseUp = () => {
+        autoFillEnd();
+        window.removeEventListener("mouseup", handleMouseUp);
+      };
+
+      window.addEventListener("mouseup", handleMouseUp);
+    },
+    [autoFillStart, autoFillEnd]
+  );
+
+  return (
+    <div
+      className="Spreadsheet__auto-fill-handle"
+      onMouseDown={handleMouseDown}
+    />
+  );
+};
+
+export default AutoFillHandle;
+
diff --git a/src/Copied.test.tsx b/src/Copied.test.tsx
index 9d4420019..04089c3cb 100644
--- a/src/Copied.test.tsx
+++ b/src/Copied.test.tsx
@@ -15,10 +15,10 @@ describe("<Copied />", () => {
         <Copied />
       </context.Provider>
     );
+    expect(
+      document.querySelector(
+        ".Spreadsheet__floating-rect.Spreadsheet__floating-rect--copied"
+      )
+    ).not.toBeNull();
   });
-  expect(
-    document.querySelector(
-      ".Spreadsheet__floating-rect.Spreadsheet__floating-rect--copied"
-    )
-  );
 });
diff --git a/src/FloatingRect.tsx b/src/FloatingRect.tsx
index f0f65f236..1021b4d26 100644
--- a/src/FloatingRect.tsx
+++ b/src/FloatingRect.tsx
@@ -7,24 +7,37 @@ export type Props = {
   dimensions?: Types.Dimensions | null | undefined;
   hidden?: boolean;
   dragging?: boolean;
+  autoFilling?: boolean;
+  className?: string;
+  children?: React.ReactNode;
 };
 
 const FloatingRect: React.FC<Props> = ({
   dimensions,
   dragging,
+  autoFilling,
   hidden,
   variant,
+  className,
+  children,
 }) => {
   const { width, height, top, left } = dimensions || {};
   return (
     <div
-      className={classnames("Spreadsheet__floating-rect", {
-        [`Spreadsheet__floating-rect--${variant}`]: variant,
-        "Spreadsheet__floating-rect--dragging": dragging,
-        "Spreadsheet__floating-rect--hidden": hidden,
-      })}
+      className={classnames(
+        "Spreadsheet__floating-rect",
+        {
+          [`Spreadsheet__floating-rect--${variant}`]: variant,
+          "Spreadsheet__floating-rect--dragging": dragging,
+          "Spreadsheet__floating-rect--auto-filling": autoFilling,
+          "Spreadsheet__floating-rect--hidden": hidden,
+        },
+        className
+      )}
       style={{ width, height, top, left }}
-    />
+    >
+      {children}
+    </div>
   );
 };
 
diff --git a/src/Selected.tsx b/src/Selected.tsx
index 3e1a2df16..31f4981dd 100644
--- a/src/Selected.tsx
+++ b/src/Selected.tsx
@@ -2,9 +2,14 @@ import * as React from "react";
 import { getSelectedDimensions } from "./util";
 import FloatingRect from "./FloatingRect";
 import useSelector from "./use-selector";
+import classNames from "classnames";
+import AutoFillHandle from "./AutoFillHandle";
 
 const Selected: React.FC = () => {
   const selected = useSelector((state) => state.selected);
+  const selectedSize = useSelector((state) =>
+    state.selected.size(state.model.data)
+  );
   const dimensions = useSelector(
     (state) =>
       selected &&
@@ -16,16 +21,22 @@ const Selected: React.FC = () => {
       )
   );
   const dragging = useSelector((state) => state.dragging);
-  const hidden = useSelector(
-    (state) => state.selected.size(state.model.data) < 2
-  );
+  const autoFilling = useSelector((state) => state.autoFilling);
+  const hidden = selectedSize === 0;
+
   return (
     <FloatingRect
       variant="selected"
       dimensions={dimensions}
       dragging={dragging}
       hidden={hidden}
-    />
+      className={classNames({
+        "Spreadsheet__selected-single": selectedSize === 1,
+      })}
+      autoFilling={autoFilling}
+    >
+      {!hidden && <AutoFillHandle />}
+    </FloatingRect>
   );
 };
 
diff --git a/src/Spreadsheet.css b/src/Spreadsheet.css
index b4346e5ac..9ca8f7d66 100755
--- a/src/Spreadsheet.css
+++ b/src/Spreadsheet.css
@@ -124,10 +124,31 @@
   border: 2px var(--outline-color) solid;
 }
 
-.Spreadsheet__floating-rect--dragging {
+.Spreadsheet__floating-rect--selected.Spreadsheet__selected-single {
+  background: none;
   border: none;
 }
 
+.Spreadsheet__floating-rect--selected.Spreadsheet__floating-rect--auto-filling {
+  background: none;
+  border: 2px var(--readonly-text-color) dashed;
+}
+
 .Spreadsheet__floating-rect--copied {
   border: 2px var(--outline-color) dashed;
 }
+
+.Spreadsheet__auto-fill-handle {
+  position: absolute;
+  bottom: 0;
+  right: 0;
+  transform: translate(50%, 50%);
+  width: 8px;
+  height: 8px;
+  background: var(--outline-color);
+  border-radius: 50%;
+  box-shadow: var(--elevation);
+  cursor: pointer;
+  z-index: 10;
+  pointer-events: auto;
+}
diff --git a/src/Spreadsheet.test.tsx b/src/Spreadsheet.test.tsx
index ec498ee51..f5647c438 100644
--- a/src/Spreadsheet.test.tsx
+++ b/src/Spreadsheet.test.tsx
@@ -165,7 +165,7 @@ describe("<Spreadsheet />", () => {
       activeCell?.getBoundingClientRect()
     );
     // Check selected is not hidden
-    expect(selected).toHaveClass("Spreadsheet__floating-rect--hidden");
+    expect(selected).not.toHaveClass("Spreadsheet__floating-rect--hidden");
     // Check onActivate is called
     expect(onActivate).toHaveBeenCalledTimes(1);
     expect(onActivate).toHaveBeenCalledWith(Point.ORIGIN);
@@ -476,6 +476,123 @@ describe("<Spreadsheet />", () => {
     );
     expect(selected).not.toHaveClass("Spreadsheet__floating-rect--hidden");
   });
+  test("auto fill handle is not rendered when no cell is selected", () => {
+    render(<Spreadsheet {...EXAMPLE_PROPS} />);
+    const element = getSpreadsheetElement();
+    const autoFillHandle = element.querySelector(
+      ".Spreadsheet__auto-fill-handle"
+    );
+    expect(autoFillHandle).toBeNull();
+  });
+  test("auto fill handle is rendered when a cell is selected", () => {
+    render(<Spreadsheet {...EXAMPLE_PROPS} />);
+    const element = getSpreadsheetElement();
+    const cell = safeQuerySelector(element, "td");
+    // Select a cell
+    fireEvent.mouseDown(cell);
+    // Check auto fill handle is rendered
+    const autoFillHandle = safeQuerySelector(
+      element,
+      ".Spreadsheet__auto-fill-handle"
+    );
+    expect(autoFillHandle).toBeInTheDocument();
+  });
+  test("auto fill handle is rendered when a range is selected", () => {
+    render(<Spreadsheet {...EXAMPLE_PROPS} />);
+    const element = getSpreadsheetElement();
+    const firstCell = safeQuerySelector(
+      element,
+      "tr:nth-of-type(2) td:nth-of-type(1)"
+    );
+    const thirdCell = safeQuerySelector(
+      element,
+      "tr:nth-of-type(3) td:nth-of-type(2)"
+    );
+    // Select first cell
+    fireEvent.mouseDown(firstCell);
+    // Extend selection to create a range
+    fireEvent.mouseDown(thirdCell, { shiftKey: true });
+    // Check auto fill handle is rendered
+    const autoFillHandle = safeQuerySelector(
+      element,
+      ".Spreadsheet__auto-fill-handle"
+    );
+    expect(autoFillHandle).toBeInTheDocument();
+  });
+  test("mousedown on auto fill handle initiates auto fill mode", () => {
+    render(<Spreadsheet {...EXAMPLE_PROPS} />);
+    const element = getSpreadsheetElement();
+    const cell = safeQuerySelector(element, "td");
+    // Select a cell
+    fireEvent.mouseDown(cell);
+    // Get auto fill handle
+    const autoFillHandle = safeQuerySelector(
+      element,
+      ".Spreadsheet__auto-fill-handle"
+    );
+    // Get selected floating rect
+    const selected = safeQuerySelector(
+      element,
+      ".Spreadsheet__floating-rect--selected"
+    );
+    // Check auto filling class is not present initially
+    expect(selected).not.toHaveClass(
+      "Spreadsheet__floating-rect--auto-filling"
+    );
+    // Trigger auto fill
+    fireEvent.mouseDown(autoFillHandle);
+    // Check auto filling class is present
+    expect(selected).toHaveClass("Spreadsheet__floating-rect--auto-filling");
+  });
+  test("auto fill continues numeric sequence 1, 2, 3", () => {
+    const onChange = jest.fn();
+    const data = createEmptyMatrix<CellType>(ROWS, COLUMNS);
+    // Set up a numeric sequence: 1, 2
+    const dataWithSequence = Matrix.set(
+      { row: 0, column: 0 },
+      { value: "1" },
+      Matrix.set({ row: 1, column: 0 }, { value: "2" }, data)
+    );
+    render(<Spreadsheet data={dataWithSequence} onChange={onChange} />);
+    const element = getSpreadsheetElement();
+    // Select first cell (1)
+    const firstCell = safeQuerySelector(
+      element,
+      "tr:nth-of-type(2) td:nth-of-type(1)"
+    );
+    fireEvent.mouseDown(firstCell);
+    // Extend selection to second cell (2) to establish pattern
+    const secondCell = safeQuerySelector(
+      element,
+      "tr:nth-of-type(3) td:nth-of-type(1)"
+    );
+    fireEvent.mouseDown(secondCell, { shiftKey: true });
+    // Get auto fill handle
+    const autoFillHandle = safeQuerySelector(
+      element,
+      ".Spreadsheet__auto-fill-handle"
+    );
+    // Start auto fill
+    fireEvent.mouseDown(autoFillHandle);
+    // Extend selection to include two more cells (simulating dragging down)
+    const fourthCell = safeQuerySelector(
+      element,
+      "tr:nth-of-type(5) td:nth-of-type(1)"
+    );
+    fireEvent.mouseDown(fourthCell, { shiftKey: true });
+    // End auto fill (trigger mouseup on window)
+    fireEvent.mouseUp(window);
+    // Check onChange was called with auto-filled data
+    expect(onChange).toHaveBeenCalled();
+    const resultData = onChange.mock.calls[
+      onChange.mock.calls.length - 1
+    ][0] as Matrix.Matrix<CellType>;
+    // Verify the sequence: 1, 2, 3, 4
+    expect(Matrix.get({ row: 0, column: 0 }, resultData)?.value).toBe("1");
+    expect(Matrix.get({ row: 1, column: 0 }, resultData)?.value).toBe("2");
+    expect(Matrix.get({ row: 2, column: 0 }, resultData)?.value).toBe(3);
+    expect(Matrix.get({ row: 3, column: 0 }, resultData)?.value).toBe(4);
+  });
 });
 
 describe("Spreadsheet Ref Methods", () => {
diff --git a/src/actions.ts b/src/actions.ts
index cade0c6c1..3a3c0b8fd 100644
--- a/src/actions.ts
+++ b/src/actions.ts
@@ -30,6 +30,8 @@ export const KEY_DOWN = "KEY_DOWN";
 export const DRAG_START = "DRAG_START";
 export const DRAG_END = "DRAG_END";
 export const COMMIT = "COMMIT";
+export const AUTO_FILL_START = "AUTO_FILL_START";
+export const AUTO_FILL_END = "AUTO_FILL_END";
 
 export type BaseAction<T extends string> = {
   type: T;
@@ -276,6 +278,18 @@ export function blur(): BlurAction {
   return { type: BLUR };
 }
 
+export type AutoFillStartAction = BaseAction<typeof AUTO_FILL_START>;
+
+export function autoFillStart(): AutoFillStartAction {
+  return { type: AUTO_FILL_START };
+}
+
+export type AutoFillEndAction = BaseAction<typeof AUTO_FILL_END>;
+
+export function autoFillEnd(): AutoFillEndAction {
+  return { type: AUTO_FILL_END };
+}
+
 export type Action =
   | SetDataAction
   | SetCreateFormulaParserAction
@@ -298,4 +312,6 @@ export type Action =
   | EditAction
   | ViewAction
   | ClearAction
-  | BlurAction;
+  | BlurAction
+  | AutoFillStartAction
+  | AutoFillEndAction;
diff --git a/src/auto-fill/auto-fill-range.test.ts b/src/auto-fill/auto-fill-range.test.ts
new file mode 100644
index 000000000..031ecaf62
--- /dev/null
+++ b/src/auto-fill/auto-fill-range.test.ts
@@ -0,0 +1,890 @@
+import * as matrix from "../matrix";
+import { PointRange } from "../point-range";
+import { CellBase } from "../types";
+import { autoFillRange } from "./auto-fill-range";
+
+describe("autoFillRange", () => {
+  // Helper function to create a simple cell
+  const cell = (value: any): CellBase => ({ value });
+
+  // Helper to extract values from matrix
+  const getValues = (
+    data: matrix.Matrix<CellBase>,
+    range: PointRange
+  ): any[] => {
+    return Array.from(range, (point) => matrix.get(point, data)?.value);
+  };
+
+  describe("Numeric - Increasing Series", () => {
+    it("should copy single numeric value (1 -> 1, 1, 1...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell(1), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 2 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([1, 1, 1]);
+    });
+
+    it("should increment by step size for two cells (1, 2 -> 3, 4, 5...)", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell(1), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell(2), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 4 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([1, 2, 3, 4, 5]);
+    });
+
+    it("should handle non-unit steps (5, 10 -> 15, 20...)", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell(5), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell(10), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 4 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([5, 10, 15, 20, 25]);
+    });
+
+    it("should handle vertical filling (1, 2 -> 3, 4, 5... in rows)", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell(1), [[]]);
+      data = matrix.set({ row: 1, column: 0 }, cell(2), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 4, column: 0 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([1, 2, 3, 4, 5]);
+    });
+
+    it("should handle decimal steps (1.5, 2.5 -> 3.5, 4.5...)", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell(1.5), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell(2.5), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 4 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([1.5, 2.5, 3.5, 4.5, 5.5]);
+    });
+
+    it("should handle three or more cells with consistent step (1, 2, 3 -> 4, 5...)", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell(1), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell(2), data);
+      data = matrix.set({ row: 0, column: 2 }, cell(3), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 5 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([1, 2, 3, 4, 5, 6]);
+    });
+  });
+
+  describe("Numeric - Decreasing Series", () => {
+    it("should handle negative steps (10, 5 -> 0, -5...)", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell(10), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell(5), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 4 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([10, 5, 0, -5, -10]);
+    });
+
+    it("should handle decreasing decimal steps (5.5, 4.0 -> 2.5, 1.0...)", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell(5.5), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell(4.0), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 4 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([5.5, 4.0, 2.5, 1.0, -0.5]);
+    });
+  });
+
+  describe.skip("Numeric - Multiplying Series", () => {
+    it("should handle multiplication pattern (2, 4 -> 8, 16...)", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell(2), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell(4), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 4 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([2, 4, 8, 16, 32]);
+    });
+
+    it("should handle multiplication with decimals (1, 1.5 -> 2.25, 3.375...)", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell(1), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell(1.5), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 4 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([1, 1.5, 2.25, 3.375, 5.0625]);
+    });
+
+    it("should handle consistent multiplication with three cells (2, 6, 18 -> 54...)", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell(2), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell(6), data);
+      data = matrix.set({ row: 0, column: 2 }, cell(18), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 4 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([2, 6, 18, 54, 162]);
+    });
+  });
+
+  describe.skip("Numeric - Dividing Series", () => {
+    it("should handle division pattern (100, 50 -> 25, 12.5...)", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell(100), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell(50), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 4 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([100, 50, 25, 12.5, 6.25]);
+    });
+
+    it("should handle consistent division with three cells (81, 27, 9 -> 3, 1)", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell(81), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell(27), data);
+      data = matrix.set({ row: 0, column: 2 }, cell(9), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 4 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([81, 27, 9, 3, 1]);
+    });
+  });
+
+  describe("Edge Cases", () => {
+    it("should return original data when no pattern is detected", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell(1), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell(3), data);
+      data = matrix.set({ row: 0, column: 2 }, cell(7), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 4 }
+      );
+      const result = autoFillRange(data, range);
+
+      // No consistent pattern, so data should remain unchanged
+      expect(getValues(result, range)).toEqual([1, 3, 7, undefined, undefined]);
+    });
+
+    it("should handle empty cells in the series", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell(1), [[]]);
+      data = matrix.set({ row: 0, column: 2 }, cell(3), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 3 }
+      );
+      const result = autoFillRange(data, range);
+
+      // Pattern should be detected across the gap
+      expect(getValues(result, range)).toEqual([1, undefined, 3, undefined]);
+    });
+
+    it("should handle range with only one cell", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell(5), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 0 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([5]);
+    });
+
+    it("should handle infinity and NaN edge cases", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell(0), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell(0), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 2 }
+      );
+      const result = autoFillRange(data, range);
+
+      // Division by zero should be handled
+      expect(getValues(result, range)).toEqual([0, 0, undefined]);
+    });
+  });
+
+  describe("Text & Numeric - Patterns", () => {
+    it("should increment number in text (Task 1 -> Task 2, Task 3...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("Task 1"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 2 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual(["Task 1", "Task 2", "Task 3"]);
+    });
+
+    it.skip("should handle number at beginning (1st Quarter -> 2nd Quarter...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("1st Quarter"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 3 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "1st Quarter",
+        "2nd Quarter",
+        "3rd Quarter",
+        "4th Quarter",
+      ]);
+    });
+
+    it.skip("should handle multiple numbers in text", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("Week 1 Day 1"), [
+        [],
+      ]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 2 }
+      );
+      const result = autoFillRange(data, range);
+
+      // Should increment the rightmost number
+      expect(getValues(result, range)).toEqual([
+        "Week 1 Day 1",
+        "Week 1 Day 2",
+        "Week 1 Day 3",
+      ]);
+    });
+
+    it("should handle padded numbers (Item 001 -> Item 002...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("Item 001"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 2 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "Item 001",
+        "Item 002",
+        "Item 003",
+      ]);
+    });
+  });
+
+  describe.skip("Dates - Consecutive Days", () => {
+    it("should fill consecutive days from single date (1/1/2025 -> 1/2/2025...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("1/1/2025"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 2 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "1/1/2025",
+        "1/2/2025",
+        "1/3/2025",
+      ]);
+    });
+
+    it("should detect weekly pattern (1/1/2025, 1/8/2025 -> 1/15/2025...)", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell("1/1/2025"), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell("1/8/2025"), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 3 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "1/1/2025",
+        "1/8/2025",
+        "1/15/2025",
+        "1/22/2025",
+      ]);
+    });
+
+    it("should handle different date formats (DD-MMM-YY)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("01-Jan-25"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 2 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "01-Jan-25",
+        "02-Jan-25",
+        "03-Jan-25",
+      ]);
+    });
+
+    it("should handle month boundaries correctly", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("1/30/2025"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 2 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "1/30/2025",
+        "1/31/2025",
+        "2/1/2025",
+      ]);
+    });
+  });
+
+  describe.skip("Dates - Fill Weekdays", () => {
+    it("should fill only weekdays, skipping weekends", () => {
+      // Assuming 1/1/2025 is a Wednesday
+      const data = matrix.set({ row: 0, column: 0 }, cell("1/1/2025"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 4 }
+      );
+      const result = autoFillRange(data, range);
+
+      // Should skip Saturday and Sunday
+      expect(getValues(result, range)).toEqual([
+        "1/1/2025", // Wed
+        "1/2/2025", // Thu
+        "1/3/2025", // Fri
+        "1/6/2025", // Mon
+        "1/7/2025", // Tue
+      ]);
+    });
+  });
+
+  describe.skip("Dates - Fill Months", () => {
+    it("should fill months from single date (1/1/2025 -> 2/1/2025...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("1/1/2025"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 2 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "1/1/2025",
+        "2/1/2025",
+        "3/1/2025",
+      ]);
+    });
+
+    it("should detect monthly pattern from two dates", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell("1/1/2025"), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell("2/1/2025"), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 4 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "1/1/2025",
+        "2/1/2025",
+        "3/1/2025",
+        "4/1/2025",
+        "5/1/2025",
+      ]);
+    });
+
+    it("should handle last day of month sequences", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell("1/31/2025"), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell("2/28/2025"), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 3 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "1/31/2025",
+        "2/28/2025",
+        "3/31/2025",
+        "4/30/2025",
+      ]);
+    });
+  });
+
+  describe.skip("Dates - Fill Years", () => {
+    it("should fill years from single date (1/1/2025 -> 1/1/2026...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("1/1/2025"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 2 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "1/1/2025",
+        "1/1/2026",
+        "1/1/2027",
+      ]);
+    });
+  });
+
+  describe.skip("Time - Patterns", () => {
+    it("should fill consecutive hours (9:00 AM -> 10:00 AM...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("9:00 AM"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 3 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "9:00 AM",
+        "10:00 AM",
+        "11:00 AM",
+        "12:00 PM",
+      ]);
+    });
+
+    it("should detect time intervals (9:00 AM, 9:30 AM -> 10:00 AM...)", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell("9:00 AM"), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell("9:30 AM"), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 4 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "9:00 AM",
+        "9:30 AM",
+        "10:00 AM",
+        "10:30 AM",
+        "11:00 AM",
+      ]);
+    });
+
+    it("should handle different time formats (hh:mm:ss)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("09:00:00"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 2 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "09:00:00",
+        "10:00:00",
+        "11:00:00",
+      ]);
+    });
+
+    it("should handle 24-hour format", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("14:00"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 2 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual(["14:00", "15:00", "16:00"]);
+    });
+
+    it("should wrap around midnight", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("11:00 PM"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 3 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "11:00 PM",
+        "12:00 AM",
+        "1:00 AM",
+        "2:00 AM",
+      ]);
+    });
+  });
+
+  describe("Built-in Lists - Days of Week", () => {
+    it("should fill consecutive days (Monday -> Tuesday...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("Monday"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 3 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "Monday",
+        "Tuesday",
+        "Wednesday",
+        "Thursday",
+      ]);
+    });
+
+    it("should handle abbreviated day names (Mon -> Tue...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("Mon"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 3 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual(["Mon", "Tue", "Wed", "Thu"]);
+    });
+
+    it("should wrap around week (Saturday -> Sunday -> Monday...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("Saturday"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 3 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "Saturday",
+        "Sunday",
+        "Monday",
+        "Tuesday",
+      ]);
+    });
+
+    it("should be case-insensitive (MONDAY -> TUESDAY...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("MONDAY"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 2 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "MONDAY",
+        "TUESDAY",
+        "WEDNESDAY",
+      ]);
+    });
+  });
+
+  describe("Built-in Lists - Months", () => {
+    it("should fill consecutive months (January -> February...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("January"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 3 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "January",
+        "February",
+        "March",
+        "April",
+      ]);
+    });
+
+    it("should handle abbreviated month names (Jan -> Feb...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("Jan"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 3 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual(["Jan", "Feb", "Mar", "Apr"]);
+    });
+
+    it("should wrap around year (November -> December -> January...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("November"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 3 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "November",
+        "December",
+        "January",
+        "February",
+      ]);
+    });
+
+    it("should preserve case (JANUARY -> FEBRUARY...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("JANUARY"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 2 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "JANUARY",
+        "FEBRUARY",
+        "MARCH",
+      ]);
+    });
+  });
+
+  describe.skip("Custom Lists", () => {
+    it("should support user-defined custom lists", () => {
+      // Example: North, South, East, West
+      const data = matrix.set({ row: 0, column: 0 }, cell("North"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 3 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "North",
+        "South",
+        "East",
+        "West",
+      ]);
+    });
+
+    it("should wrap custom lists (West -> North...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("West"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 2 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual(["West", "North", "South"]);
+    });
+  });
+
+  describe("Formula - Relative References", () => {
+    it("should shift relative references when filling down (=A1 -> =A2...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("=A1"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 2, column: 0 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual(["=A1", "=A2", "=A3"]);
+    });
+
+    it("should shift relative references when filling right (=A1 -> =B1...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("=A1"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 2 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual(["=A1", "=B1", "=C1"]);
+    });
+
+    it("should shift both row and column in diagonal fill (=A1+B2 -> =B2+C3...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("=A1+B2"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 2, column: 2 }
+      );
+      const result = autoFillRange(data, range);
+
+      const values = getValues(result, range);
+      expect(values[0]).toBe("=A1+B2");
+      expect(values[4]).toBe("=B2+C3"); // middle cell in 3x3 grid
+      expect(values[8]).toBe("=C3+D4"); // bottom-right
+    });
+  });
+
+  describe("Formula - Absolute References", () => {
+    it("should not shift absolute references (=$A$1 -> =$A$1...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("=$A$1"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 2, column: 0 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual(["=$A$1", "=$A$1", "=$A$1"]);
+    });
+
+    it("should handle mixed references - absolute column (=$A1 -> =$A2...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("=$A1"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 2, column: 0 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual(["=$A1", "=$A2", "=$A3"]);
+    });
+
+    it("should handle mixed references - absolute row (=A$1 -> =B$1...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("=A$1"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 2 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual(["=A$1", "=B$1", "=C$1"]);
+    });
+
+    it("should handle complex formulas (=$A$1+B1 -> =$A$1+B2...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("=$A$1+B1"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 2, column: 0 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "=$A$1+B1",
+        "=$A$1+B2",
+        "=$A$1+B3",
+      ]);
+    });
+  });
+
+  describe("Formula - Functions and Operations", () => {
+    it("should update references in SUM formulas (=SUM(A1:A3) -> =SUM(A2:A4)...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("=SUM(A1:A3)"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 2, column: 0 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "=SUM(A1:A3)",
+        "=SUM(A2:A4)",
+        "=SUM(A3:A5)",
+      ]);
+    });
+
+    it("should handle arithmetic operations (=A1*2 -> =A2*2...)", () => {
+      const data = matrix.set({ row: 0, column: 0 }, cell("=A1*2"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 2, column: 0 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual(["=A1*2", "=A2*2", "=A3*2"]);
+    });
+
+    it("should handle nested functions (=IF(A1>0,SUM(B1:C1),0))", () => {
+      const data = matrix.set(
+        { row: 0, column: 0 },
+        cell("=IF(A1>0,SUM(B1:C1),0)"),
+        [[]]
+      );
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 2, column: 0 }
+      );
+      const result = autoFillRange(data, range);
+
+      expect(getValues(result, range)).toEqual([
+        "=IF(A1>0,SUM(B1:C1),0)",
+        "=IF(A2>0,SUM(B2:C2),0)",
+        "=IF(A3>0,SUM(B3:C3),0)",
+      ]);
+    });
+  });
+
+  describe.skip("Formula - Array Formulas", () => {
+    it("should handle array formula spilling", () => {
+      // Array formulas might not need traditional fill behavior
+      const data = matrix.set({ row: 0, column: 0 }, cell("={A1:A5}"), [[]]);
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 2, column: 0 }
+      );
+      const result = autoFillRange(data, range);
+
+      // Behavior might vary - could maintain same formula or adjust
+      expect(getValues(result, range)).toEqual([
+        "={A1:A5}",
+        "={A2:A6}",
+        "={A3:A7}",
+      ]);
+    });
+  });
+
+  describe.skip("Mixed Content", () => {
+    it("should handle mixed numeric and text cells", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell(1), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell("Text"), data);
+      data = matrix.set({ row: 0, column: 2 }, cell(2), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 4 }
+      );
+      const result = autoFillRange(data, range);
+
+      // Should copy pattern or individual values
+      expect(getValues(result, range)).toEqual([
+        1,
+        "Text",
+        2,
+        undefined,
+        undefined,
+      ]);
+    });
+
+    it("should repeat patterns when detected", () => {
+      let data = matrix.set({ row: 0, column: 0 }, cell("A"), [[]]);
+      data = matrix.set({ row: 0, column: 1 }, cell("B"), data);
+
+      const range = new PointRange(
+        { row: 0, column: 0 },
+        { row: 0, column: 5 }
+      );
+      const result = autoFillRange(data, range);
+
+      // Should repeat A, B, A, B...
+      expect(getValues(result, range)).toEqual(["A", "B", "A", "B", "A", "B"]);
+    });
+  });
+});
diff --git a/src/auto-fill/auto-fill-range.ts b/src/auto-fill/auto-fill-range.ts
new file mode 100644
index 000000000..52854706d
--- /dev/null
+++ b/src/auto-fill/auto-fill-range.ts
@@ -0,0 +1,118 @@
+/**
+ * @module
+ *
+ * Main orchestrator for the auto-fill system.
+ *
+ * This module brings together all auto-fillers and applies them to ranges.
+ * When auto-fill is triggered, it:
+ *
+ * 1. **Extracts the series**: Reads values from the selected range
+ * 2. **Finds a matching pattern**: Tries each auto-filler in priority order
+ * 3. **Generates values**: Uses the matched auto-filler to fill empty cells
+ *
+ * ## Auto-Filler Priority Order
+ *
+ * More specific patterns are checked before general ones to avoid false matches:
+ *
+ * 1. **Formulas** - Check first to avoid being matched as "repeating"
+ * 2. **Numeric patterns** - Increasing/decreasing sequences
+ * 3. **Text with numbers** - "Task 1", "Task 2"...
+ * 4. **Date lists** - Days of week, months
+ * 5. **General** - Repeating values (fallback)
+ *
+ * @example
+ * ```typescript
+ * const data = [
+ *   [{ value: 1 }, { value: 2 }],
+ *   [{ value: undefined }, { value: undefined }]
+ * ];
+ * const range = new PointRange({row: 0, column: 0}, {row: 3, column: 0});
+ * const result = autoFillRange(data, range);
+ * // result will have cells filled: 1, 2, 3, 4
+ * ```
+ */
+
+import * as matrix from "../matrix";
+import { PointRange } from "../point-range";
+import { CellBase } from "../types";
+import { AutoFiller } from "./types";
+import { numericAutoFillers } from "./numeric";
+import { textAutoFillers } from "./text-with-number";
+import { dateAutoFillers } from "./date";
+import { formulaAutoFillers } from "./formula";
+import { generalAutoFillers } from "./general";
+
+/**
+ * Registry of all available auto-fillers
+ * Order matters: more specific patterns should come before more general ones
+ */
+const autoFillers: AutoFiller<any, any>[] = [
+  ...formulaAutoFillers, // Formula patterns (check first to avoid repeating match)
+  ...numericAutoFillers, // Numeric patterns (increasing, decreasing)
+  ...textAutoFillers, // Text with numbers (Task 1, Task 2, etc.)
+  ...dateAutoFillers, // Days of week and months
+  ...generalAutoFillers, // Repeating/copying (most general, check last)
+];
+
+/**
+ * Auto-fills a range based on detected patterns in the existing data
+ * @param data - The spreadsheet data matrix
+ * @param range - The range to auto-fill
+ * @returns Updated data matrix with auto-filled values
+ */
+export function autoFillRange<T>(
+  data: matrix.Matrix<CellBase<T>>,
+  range: PointRange
+): matrix.Matrix<CellBase<T>> {
+  const series = Array.from(range, (point) => matrix.get(point, data));
+  const autoFiller = autoFillers.find((it) => it.match(series));
+  if (!autoFiller) return data;
+  const matchDetails = autoFiller.match(series);
+
+  // Find the first non-empty cell in the series (for formulas, we start from the first)
+  let firstFilledIndex = -1;
+  for (let i = 0; i < series.length; i++) {
+    if (series[i] !== undefined) {
+      firstFilledIndex = i;
+      break;
+    }
+  }
+
+  // Find the last non-empty cell in the series
+  let lastFilledIndex = -1;
+  for (let i = series.length - 1; i >= 0; i--) {
+    if (series[i] !== undefined) {
+      lastFilledIndex = i;
+      break;
+    }
+  }
+
+  if (lastFilledIndex === -1) return data;
+
+  const points = Array.from(range);
+
+  // Start from the last filled cell's value
+  let currentValue: any = series[lastFilledIndex]?.value;
+
+  let updatedData = data;
+
+  // Fill only cells after the last filled cell
+  for (let i = lastFilledIndex + 1; i < points.length; i++) {
+    const point = points[i];
+    const startPoint = points[firstFilledIndex];
+    const index = i - lastFilledIndex - 1;
+
+    const context = { point, startPoint, index };
+
+    // Auto-filler returns the final display value
+    const nextValue = autoFiller.nextValue(currentValue, matchDetails, context);
+    currentValue = nextValue;
+
+    const currentCell = matrix.get(point, updatedData);
+    const nextCell = currentCell
+      ? { ...currentCell, value: nextValue }
+      : ({ value: nextValue } as CellBase<T>);
+    updatedData = matrix.set(point, nextCell, updatedData);
+  }
+  return updatedData;
+}
diff --git a/src/auto-fill/date.ts b/src/auto-fill/date.ts
new file mode 100644
index 000000000..6f8c3862e
--- /dev/null
+++ b/src/auto-fill/date.ts
@@ -0,0 +1,217 @@
+/**
+ * @module
+ *
+ * Date-related built-in list patterns for auto-fill.
+ *
+ * This module provides auto-fillers for common date-related lists:
+ * - **Days of week**: "Monday" → "Tuesday" → "Wednesday"
+ * - **Days of week (short)**: "Mon" → "Tue" → "Wed"
+ * - **Months**: "January" → "February" → "March"
+ * - **Months (short)**: "Jan" → "Feb" → "Mar"
+ *
+ * Features:
+ * - **Wrapping**: Saturday → Sunday → Monday
+ * - **Case preservation**: "MONDAY" → "TUESDAY", "monday" → "tuesday"
+ *
+ * @example
+ * ["Monday", "Tuesday"] → "Wednesday", "Thursday", "Friday"...
+ *
+ * @example
+ * ["JANUARY"] → "FEBRUARY", "MARCH", "APRIL"...
+ */
+
+import { AutoFiller, Series } from "./types";
+
+// Built-in lists
+const DAYS_OF_WEEK = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday",
+];
+
+const DAYS_OF_WEEK_SHORT = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+
+const MONTHS = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December",
+];
+
+const MONTHS_SHORT = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec",
+];
+
+export type ListFactor = {
+  list: string[];
+  index: number;
+  caseFormatter: (s: string) => string;
+};
+
+export type ListValue = {
+  index: number;
+};
+
+/**
+ * Determines the case formatter based on the input string
+ */
+function getCaseFormatter(
+  input: string,
+  reference: string
+): (s: string) => string {
+  // Check if all uppercase
+  if (input === input.toUpperCase() && input !== input.toLowerCase()) {
+    return (s: string) => s.toUpperCase();
+  }
+  // Check if all lowercase
+  if (input === input.toLowerCase() && input !== input.toUpperCase()) {
+    return (s: string) => s.toLowerCase();
+  }
+  // Otherwise preserve original case (title case or mixed)
+  return (s: string) => s;
+}
+
+/**
+ * Matches a series against a predefined list
+ */
+function matchListSeries(
+  series: Series<string>,
+  list: string[]
+):
+  | {
+      list: string[];
+      index: number;
+      caseFormatter: (s: string) => string;
+    }
+  | undefined {
+  if (series.length === 0) return;
+  const firstItem = series.find((item) => item !== undefined);
+  if (!firstItem || typeof firstItem.value !== "string") return;
+
+  // Find the item in the list (case-insensitive)
+  const normalizedList = list.map((item) => item.toLowerCase());
+  const firstValue = String(firstItem.value);
+  const firstValueLower = firstValue.toLowerCase();
+  let startIndex = normalizedList.indexOf(firstValueLower);
+
+  if (startIndex === -1) return;
+
+  // Determine case formatter based on first value
+  const caseFormatter = getCaseFormatter(firstValue, list[startIndex]);
+
+  // For single cell, return the pattern
+  if (series.filter((item) => item !== undefined).length === 1) {
+    return { list, index: startIndex, caseFormatter };
+  }
+
+  // Verify pattern holds for all items (should increment through the list)
+  let expectedIndex = startIndex;
+  for (const item of series) {
+    if (item === undefined) continue;
+    const itemValueLower = String(item.value).toLowerCase();
+    if (normalizedList[expectedIndex] !== itemValueLower) return;
+    expectedIndex = (expectedIndex + 1) % list.length;
+  }
+
+  return { list, index: startIndex, caseFormatter };
+}
+
+/** Days of week (full names) */
+export const daysOfWeek: AutoFiller<ListFactor, string> = {
+  match: (series) => matchListSeries(series, DAYS_OF_WEEK),
+  nextValue: (previousValue, matchDetails, _context) => {
+    // Extract current index from the list
+    const currentIndex = matchDetails.list.findIndex(
+      (item) => item.toLowerCase() === String(previousValue).toLowerCase()
+    );
+    const nextIndex =
+      currentIndex !== -1 ? (currentIndex + 1) % matchDetails.list.length : 0;
+    const baseValue = matchDetails.list[nextIndex];
+    return matchDetails.caseFormatter(baseValue);
+  },
+};
+
+/** Days of week (short names) */
+export const daysOfWeekShort: AutoFiller<ListFactor, string> = {
+  match: (series) => matchListSeries(series, DAYS_OF_WEEK_SHORT),
+  nextValue: (previousValue, matchDetails, _context) => {
+    const currentIndex = matchDetails.list.findIndex(
+      (item) => item.toLowerCase() === String(previousValue).toLowerCase()
+    );
+    const nextIndex =
+      currentIndex !== -1 ? (currentIndex + 1) % matchDetails.list.length : 0;
+    const baseValue = matchDetails.list[nextIndex];
+    return matchDetails.caseFormatter(baseValue);
+  },
+};
+
+/** Months (full names) */
+export const months: AutoFiller<ListFactor, string> = {
+  match: (series) => matchListSeries(series, MONTHS),
+  nextValue: (previousValue, matchDetails, _context) => {
+    const currentIndex = matchDetails.list.findIndex(
+      (item) => item.toLowerCase() === String(previousValue).toLowerCase()
+    );
+    const nextIndex =
+      currentIndex !== -1 ? (currentIndex + 1) % matchDetails.list.length : 0;
+    const baseValue = matchDetails.list[nextIndex];
+    return matchDetails.caseFormatter(baseValue);
+  },
+};
+
+/** Months (short names) */
+export const monthsShort: AutoFiller<ListFactor, string> = {
+  match: (series) => matchListSeries(series, MONTHS_SHORT),
+  nextValue: (previousValue, matchDetails, _context) => {
+    const currentIndex = matchDetails.list.findIndex(
+      (item) => item.toLowerCase() === String(previousValue).toLowerCase()
+    );
+    const nextIndex =
+      currentIndex !== -1 ? (currentIndex + 1) % matchDetails.list.length : 0;
+    const baseValue = matchDetails.list[nextIndex];
+    return matchDetails.caseFormatter(baseValue);
+  },
+};
+
+/**
+ * Converts a ListValue with its match details to its display string
+ */
+export function formatList(value: ListValue, matchDetails: ListFactor): string {
+  const baseValue = matchDetails.list[value.index];
+  return matchDetails.caseFormatter
+    ? matchDetails.caseFormatter(baseValue)
+    : baseValue;
+}
+
+/**
+ * Ordered list of date-related auto-fillers (days of week, months)
+ */
+export const dateAutoFillers: AutoFiller<any, any>[] = [
+  daysOfWeek,
+  daysOfWeekShort,
+  months,
+  monthsShort,
+];
diff --git a/src/auto-fill/formula.ts b/src/auto-fill/formula.ts
new file mode 100644
index 000000000..1710dc3c4
--- /dev/null
+++ b/src/auto-fill/formula.ts
@@ -0,0 +1,152 @@
+/**
+ * @module
+ *
+ * Formula pattern detection with cell reference updating.
+ *
+ * This module handles auto-filling formulas while intelligently updating cell references:
+ * - **Relative references**: `=A1` → `=A2` (filling down), `=A1` → `=B1` (filling right)
+ * - **Absolute references**: `=$A$1` remains `=$A$1` in all directions
+ * - **Mixed references**: `=$A1` (absolute column), `=A$1` (absolute row)
+ * - **Range references**: `=SUM(A1:A3)` → `=SUM(A2:A4)`
+ * - **Complex formulas**: Works with any function (IF, VLOOKUP, nested, etc.)
+ *
+ * The module uses regex to parse cell references and respects the `$` symbol
+ * for absolute positioning.
+ *
+ * @example
+ * // Relative reference filling down
+ * ["=A1", "=A2"] → "=A3", "=A4", "=A5"...
+ *
+ * @example
+ * // Mixed reference with absolute column
+ * ["=$A$1+B1"] → "=$A$1+B2", "=$A$1+B3"...
+ *
+ * @example
+ * // Range reference
+ * ["=SUM(A1:A3)"] → "=SUM(A2:A4)", "=SUM(A3:A5)"...
+ */
+
+import { AutoFiller } from "./types";
+import { isFormulaValue, extractFormula } from "../engine/formula";
+
+/**
+ * Updates cell references in a formula based on offset from the starting point
+ */
+function updateFormulaReferences(
+  formula: string,
+  rowOffset: number,
+  colOffset: number
+): string {
+  // Match cell references like A1, $A1, A$1, $A$1, and ranges like A1:B2
+  return formula.replace(
+    /(\$?)([A-Z]+)(\$?)(\d+)(?::(\$?)([A-Z]+)(\$?)(\d+))?/g,
+    (match, colAbs1, col1, rowAbs1, row1, colAbs2, col2, rowAbs2, row2) => {
+      // Handle first cell reference
+      let newCol1 = col1;
+      let newRow1 = parseInt(row1, 10);
+
+      // Update column if not absolute
+      if (!colAbs1) {
+        const colNum = columnToNumber(col1);
+        const newColNum = colNum + colOffset;
+        if (newColNum >= 0) {
+          newCol1 = numberToColumn(newColNum);
+        }
+      }
+
+      // Update row if not absolute
+      if (!rowAbs1) {
+        newRow1 += rowOffset;
+        if (newRow1 < 1) newRow1 = 1;
+      }
+
+      let result = `${colAbs1}${newCol1}${rowAbs1}${newRow1}`;
+
+      // Handle range reference if present
+      if (col2 && row2) {
+        let newCol2 = col2;
+        let newRow2 = parseInt(row2, 10);
+
+        // Update second column if not absolute
+        if (!colAbs2) {
+          const colNum = columnToNumber(col2);
+          const newColNum = colNum + colOffset;
+          if (newColNum >= 0) {
+            newCol2 = numberToColumn(newColNum);
+          }
+        }
+
+        // Update second row if not absolute
+        if (!rowAbs2) {
+          newRow2 += rowOffset;
+          if (newRow2 < 1) newRow2 = 1;
+        }
+
+        result += `:${colAbs2}${newCol2}${rowAbs2}${newRow2}`;
+      }
+
+      return result;
+    }
+  );
+}
+
+/**
+ * Converts column letter(s) to a number (A=0, B=1, ..., Z=25, AA=26, etc.)
+ */
+function columnToNumber(col: string): number {
+  let result = 0;
+  for (let i = 0; i < col.length; i++) {
+    result = result * 26 + (col.charCodeAt(i) - 65 + 1);
+  }
+  return result - 1; // Make it 0-indexed
+}
+
+/**
+ * Converts a number to column letter(s) (0=A, 1=B, ..., 25=Z, 26=AA, etc.)
+ */
+function numberToColumn(num: number): string {
+  let result = "";
+  num = num + 1; // Make it 1-indexed for the calculation
+  while (num > 0) {
+    const remainder = (num - 1) % 26;
+    result = String.fromCharCode(65 + remainder) + result;
+    num = Math.floor((num - 1) / 26);
+  }
+  return result;
+}
+
+/**
+ * Formula auto-filler that handles relative and absolute cell references
+ */
+export const formula: AutoFiller<string, string> = {
+  match: (series) => {
+    if (series.length === 0) return;
+    const firstItem = series.find((item) => item !== undefined);
+    if (!firstItem || !isFormulaValue(firstItem.value)) return;
+
+    const formulaText = extractFormula(String(firstItem.value));
+
+    // Return just the formula text as the factor
+    return formulaText;
+  },
+  nextValue: (_previousValue, matchDetails, context) => {
+    // matchDetails is the original formula string from match()
+    // context contains the target point and start point
+    const formulaText = matchDetails;
+    const rowOffset = context.point.row - context.startPoint.row;
+    const colOffset = context.point.column - context.startPoint.column;
+
+    const updatedFormula = updateFormulaReferences(
+      formulaText,
+      rowOffset,
+      colOffset
+    );
+
+    return `=${updatedFormula}`;
+  },
+};
+
+/**
+ * Ordered list of formula auto-fillers
+ */
+export const formulaAutoFillers: AutoFiller<any, any>[] = [formula];
diff --git a/src/auto-fill/general.ts b/src/auto-fill/general.ts
new file mode 100644
index 000000000..1a1c36e4b
--- /dev/null
+++ b/src/auto-fill/general.ts
@@ -0,0 +1,47 @@
+/**
+ * @module
+ *
+ * General/fallback patterns for auto-fill operations.
+ *
+ * This module provides the most general auto-fill patterns that match when more specific
+ * patterns don't apply. Currently includes:
+ * - **Repeating**: Copies identical values when all cells in the series are the same
+ *
+ * These auto-fillers should be checked last in the priority order since they match
+ * very broad patterns.
+ *
+ * @example
+ * ["Hello", "Hello"] → "Hello", "Hello", "Hello"...
+ */
+
+import { AutoFiller } from "./types";
+
+/**
+ * Repeating/copying auto-filler - matches when all values are the same
+ * This is the most general pattern and should be checked last
+ * Requires at least one non-undefined value to match
+ */
+export const repeating: AutoFiller<any, any> = {
+  match: (series) => {
+    let curr: any | undefined;
+    let hasValue = false;
+    for (const item of series) {
+      if (item === undefined) continue;
+      if (curr === undefined) {
+        curr = item?.value;
+        hasValue = true;
+      }
+      if (item?.value !== curr) {
+        return;
+      }
+    }
+    return hasValue ? curr : undefined;
+  },
+  nextValue: (previousValue, _matchDetails, _context) => previousValue,
+};
+
+/**
+ * Ordered list of general auto-fillers
+ * These are the most general patterns and should be checked last
+ */
+export const generalAutoFillers: AutoFiller<any, any>[] = [repeating];
diff --git a/src/auto-fill/index.ts b/src/auto-fill/index.ts
new file mode 100644
index 000000000..81fe72a29
--- /dev/null
+++ b/src/auto-fill/index.ts
@@ -0,0 +1,53 @@
+/**
+ * @module
+ *
+ * Auto-fill functionality for the spreadsheet with intelligent pattern detection.
+ *
+ * This module provides an Excel-style auto-fill system that detects patterns in selected
+ * cells and automatically continues them when dragging the fill handle.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { autoFillRange } from './auto-fill';
+ *
+ * const updatedData = autoFillRange(data, range);
+ * ```
+ *
+ * ## Architecture
+ *
+ * - **auto-fill-range.ts** - Main orchestrator that applies auto-fillers
+ *
+ * The auto-fill system uses specialized auto-fillers:
+ * - **numeric.ts** - Numeric sequences (1, 2, 3...)
+ * - **text-with-number.ts** - Text with numbers (Task 1 → Task 2)
+ * - **date.ts** - Days/months lists (Monday → Tuesday)
+ * - **formula.ts** - Formula reference updating (=A1 → =A2)
+ * - **general.ts** - Fallback patterns (repeating values)
+ *
+ * ## Adding New Auto-Fillers
+ *
+ * 1. Create an `AutoFiller` implementation in the appropriate module
+ * 2. Add it to the module's exported array
+ * 3. It will automatically be included in the priority chain
+ *
+ * @example
+ * ```typescript
+ * // Create custom auto-filler
+ * export const myPattern: AutoFiller<MyFactor, MyValue> = {
+ *   match: (series) => { ... },
+ *   nextValue: (prev, factor, context) => { ... }
+ * };
+ *
+ * // Add to module exports
+ * export const myAutoFillers = [myPattern];
+ * ```
+ */
+
+export { autoFillRange } from "./auto-fill-range";
+export type { AutoFiller, Series } from "./types";
+export * from "./numeric";
+export * from "./text-with-number";
+export * from "./date";
+export * from "./formula";
+export * from "./general";
diff --git a/src/auto-fill/numeric.ts b/src/auto-fill/numeric.ts
new file mode 100644
index 000000000..722173601
--- /dev/null
+++ b/src/auto-fill/numeric.ts
@@ -0,0 +1,105 @@
+/**
+ * @module
+ *
+ * Numeric pattern detection for auto-fill operations.
+ *
+ * This module detects and continues numeric sequences with consistent steps:
+ * - **Increasing**: 1, 2, 3... or 1.5, 2.5, 3.5...
+ * - **Decreasing**: 10, 5, 0... or 100, 90, 80...
+ *
+ * Multiplicative patterns (×2, ÷2) are disabled as they can conflict with additive patterns.
+ * For example, the series [1, 2] could be either +1 or ×2.
+ *
+ * @example
+ * // Increasing by 1
+ * [1, 2, 3] → 4, 5, 6...
+ *
+ * @example
+ * // Decreasing by 5
+ * [10, 5, 0] → -5, -10, -15...
+ */
+
+import { AutoFiller, Series } from "./types";
+
+/**
+ * Checks if a series contains only numeric values and has at least one non-undefined numeric item
+ */
+function isNumberSeries(series: Series): series is Series<number> {
+  let hasNumericValue = false;
+  const allNumericOrUndefined = series.every((item) => {
+    const isNumeric =
+      item && item.value !== undefined && !isNaN(Number(item.value));
+    if (isNumeric) {
+      hasNumericValue = true;
+    }
+    return !item || item.value === undefined || isNumeric;
+  });
+  return allNumericOrUndefined && hasNumericValue;
+}
+
+/**
+ * Matches a numeric series with a consistent pattern defined by the condition function
+ */
+function matchNumberSeries(
+  series: Series<number>,
+  condition: (a: number, b: number) => number
+): number | undefined {
+  if (!isNumberSeries(series)) {
+    return;
+  }
+  let curr: number | undefined = undefined;
+  for (const [index, item] of series.entries()) {
+    const nextItem = series[index + 1];
+    if (item === undefined) continue;
+    if (nextItem === undefined) continue;
+    const nextResult = condition(Number(item.value), Number(nextItem.value));
+    if (!isFinite(nextResult)) return;
+    if (!curr) {
+      curr = nextResult;
+      continue;
+    }
+    if (curr !== nextResult) {
+      return;
+    }
+  }
+  return curr;
+}
+
+/** Increasing numeric series (e.g., 1, 2, 3...) */
+export const increasing: AutoFiller<number, number> = {
+  match: (series) => matchNumberSeries(series, (a, b) => b - a),
+  nextValue: (previousValue, matchDetails, _context) =>
+    Number(previousValue) + matchDetails,
+};
+
+/** Decreasing numeric series (e.g., 10, 5, 0...) */
+export const decreasing: AutoFiller<number, number> = {
+  match: (series) => matchNumberSeries(series, (a, b) => a - b),
+  nextValue: (previousValue, matchDetails, _context) =>
+    Number(previousValue) - matchDetails,
+};
+
+/** Multiplying numeric series (e.g., 2, 4, 8...) */
+export const multiplying: AutoFiller<number, number> = {
+  match: (series) => matchNumberSeries(series, (a, b) => b / a),
+  nextValue: (previousValue, matchDetails, _context) =>
+    Number(previousValue) * matchDetails,
+};
+
+/** Dividing numeric series (e.g., 100, 50, 25...) */
+export const dividing: AutoFiller<number, number> = {
+  match: (series) => matchNumberSeries(series, (a, b) => a / b),
+  nextValue: (previousValue, matchDetails, _context) =>
+    Number(previousValue) / matchDetails,
+};
+
+/**
+ * Ordered list of numeric auto-fillers
+ * Note: multiplicative patterns are commented out as they can conflict with additive patterns
+ */
+export const numericAutoFillers: AutoFiller<any, any>[] = [
+  increasing,
+  decreasing,
+  // multiplying,  // Disabled: can conflict with additive patterns like 1,2 vs 2,4
+  // dividing,     // Disabled: can conflict with additive patterns
+];
diff --git a/src/auto-fill/text-with-number.ts b/src/auto-fill/text-with-number.ts
new file mode 100644
index 000000000..554422658
--- /dev/null
+++ b/src/auto-fill/text-with-number.ts
@@ -0,0 +1,93 @@
+/**
+ * @module
+ *
+ * Text with numeric suffix pattern detection.
+ *
+ * This module detects and increments text strings that end with numbers:
+ * - **Simple**: "Task 1" → "Task 2" → "Task 3"
+ * - **Zero-padded**: "Item 001" → "Item 002" → "Item 003"
+ *
+ * The padding is preserved when incrementing. Only numbers at the end of strings
+ * are supported (e.g., "Task 1" works, but "1 Task" does not).
+ *
+ * @example
+ * ["Task 1", "Task 2"] → "Task 3", "Task 4", "Task 5"...
+ *
+ * @example
+ * ["Item 001"] → "Item 002", "Item 003", "Item 004"...
+ */
+
+import { AutoFiller } from "./types";
+
+export type TextWithNumberFactor = {
+  prefix: string;
+  number: number;
+  padding: number;
+};
+
+/**
+ * Text with numeric suffix incrementing (e.g., "Task 1" -> "Task 2")
+ * Supports zero-padded numbers (e.g., "Item 001" -> "Item 002")
+ */
+export const textWithNumber: AutoFiller<TextWithNumberFactor, string> = {
+  match: (series) => {
+    if (series.length === 0) return;
+    const firstItem = series.find((item) => item !== undefined);
+    if (!firstItem || typeof firstItem.value !== "string") return;
+
+    const match = String(firstItem.value).match(/^(.*?)(\d+)(.*)$/);
+    if (!match) return;
+
+    const [, prefix, numberStr, suffix] = match;
+    // Only handle cases where number is at the end (suffix is empty)
+    if (suffix !== "") return;
+
+    const startNumber = parseInt(numberStr, 10);
+    const padding = numberStr.length;
+    const step = 1;
+
+    // For single cell, just return the pattern
+    if (series.filter((item) => item !== undefined).length === 1) {
+      return { prefix, number: startNumber, padding };
+    }
+
+    // Verify pattern holds for all items
+    let expectedNumber = startNumber;
+    for (const item of series) {
+      if (item === undefined) continue;
+      const itemMatch = String(item.value).match(/^(.*?)(\d+)(.*)$/);
+      if (!itemMatch) return;
+      const [, itemPrefix, itemNumberStr, itemSuffix] = itemMatch;
+      if (itemSuffix !== "") return;
+      const itemNumber = parseInt(itemNumberStr, 10);
+      if (itemPrefix !== prefix || itemNumber !== expectedNumber) return;
+      expectedNumber += step;
+    }
+
+    return { prefix, number: startNumber, padding };
+  },
+  nextValue: (previousValue, matchDetails, _context) => {
+    // Extract number from previous value if it's a string
+    const currentNumber =
+      typeof previousValue === "string"
+        ? parseInt(previousValue.match(/\d+/)?.[0] || "0", 10)
+        : 0;
+
+    const nextNumber = currentNumber + 1;
+    const paddedNumber = String(nextNumber).padStart(matchDetails.padding, "0");
+    return `${matchDetails.prefix}${paddedNumber}`;
+  },
+};
+
+/**
+ * Converts a TextWithNumberFactor to its display string
+ */
+export function formatTextWithNumber(factor: TextWithNumberFactor): string {
+  const numStr = String(factor.number).padStart(factor.padding || 0, "0");
+  return `${factor.prefix}${numStr}`;
+}
+
+/**
+ * Ordered list of text-with-number auto-fillers
+ */
+export const textAutoFillers: AutoFiller<any, any>[] = [textWithNumber];
diff --git a/src/auto-fill/types.ts b/src/auto-fill/types.ts
new file mode 100644
index 000000000..299c95527
--- /dev/null
+++ b/src/auto-fill/types.ts
@@ -0,0 +1,33 @@
+/**
+ * @module
+ *
+ * Core type definitions for the auto-fill system.
+ */
+
+import { CellBase } from "../types";
+import { Point } from "../point";
+
+/** A series of cells (may include undefined for empty cells) */
+export type Series<T = any> = Array<CellBase<T> | undefined>;
+
+/** Context provided to auto-filler operations */
+export type AutoFillContext = {
+  /** The target point being filled */
+  point: Point;
+  /** The starting point of the pattern */
+  startPoint: Point;
+  /** The index in the fill sequence (0-based from start) */
+  index: number;
+};
+
+/** Auto-filler interface for pattern detection and value generation */
+export type AutoFiller<TMatchDetails, TValue> = {
+  /** Matches a series and returns match details/pattern descriptor, or undefined if no match */
+  match: (series: Series) => TMatchDetails | undefined;
+  /** Generates the next value given the previous value, the match details, and the context */
+  nextValue: (
+    previousValue: TValue,
+    matchDetails: TMatchDetails,
+    context: AutoFillContext
+  ) => TValue;
+};
diff --git a/src/reducer.ts b/src/reducer.ts
index cb370e6fd..a173bab3f 100644
--- a/src/reducer.ts
+++ b/src/reducer.ts
@@ -13,6 +13,7 @@ import {
 import { isActive } from "./util";
 import * as Actions from "./actions";
 import { Model, updateCellValue, createFormulaParser } from "./engine";
+import { autoFillRange } from "./auto-fill";
 
 export const INITIAL_STATE: Types.StoreState = {
   active: null,
@@ -27,6 +28,7 @@ export const INITIAL_STATE: Types.StoreState = {
   selected: new EmptySelection(),
   copied: null,
   lastCommit: null,
+  autoFilling: false,
 };
 
 export default function reducer(
@@ -332,21 +334,33 @@ export default function reducer(
       return { ...state, ...commit(changes) };
     }
 
+    case Actions.AUTO_FILL_START: {
+      return { ...state, autoFilling: true };
+    }
+
+    case Actions.AUTO_FILL_END: {
+      const { active, selected } = state;
+
+      const nextState = { ...state, autoFilling: false };
+
+      if (!active || !selected) {
+        return nextState;
+      }
+
+      const nextData = autoFill(nextState.model.data, selected, active);
+      return nextData === nextState.model.data
+        ? nextState
+        : {
+            ...nextState,
+            model: new Model(state.model.createFormulaParser, nextData),
+          };
+    }
+
     default:
       throw new Error("Unknown action");
   }
 }
 
-// const reducer = createReducer(INITIAL_STATE, (builder) => {
-//   builder.addMatcher(
-//     (action) =>
-//       action.type === Actions.copy.type || action.type === Actions.cut.type,
-//     (state, action) => {
-
-//     }
-//   );
-// });
-
 // // Shared reducers
 
 function edit(state: Types.StoreState): Types.StoreState {
@@ -679,3 +693,18 @@ export function modifyEntireColumnsSelection(
   );
   return nextSelection.normalizeTo(data);
 }
+
+/** Autofill the given selected range in given data according to active */
+export function autoFill<T extends Types.CellBase>(
+  data: Matrix.Matrix<T>,
+  selected: Selection,
+  active: Point.Point
+): Matrix.Matrix<T> {
+  const activeCell = Matrix.get(active, data);
+  if (!activeCell) {
+    return data;
+  }
+  const range = selected.toRange(data);
+  if (!range) return data;
+  return autoFillRange(data, range) as Matrix.Matrix<T>;
+}
diff --git a/src/types.ts b/src/types.ts
index fa47a46af..86db9966f 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -61,6 +61,7 @@ export type StoreState<Cell extends CellBase = CellBase> = {
   dragging: boolean;
   lastChanged: Point | null;
   lastCommit: null | CellChange<Cell>[];
+  autoFilling: boolean;
 };
 
 export type CellChange<Cell extends CellBase = CellBase> = {
diff --git a/src/util.test.ts b/src/util.test.ts
index 47fb64166..7859e13da 100644
--- a/src/util.test.ts
+++ b/src/util.test.ts
@@ -61,6 +61,7 @@ const EXAMPLE_STATE: Types.StoreState = {
   selected: new EmptySelection(),
   copied: null,
   lastCommit: null,
+  autoFilling: false,
 };
 const EXAMPLE_STRING = "EXAMPLE_STRING";
 
diff --git a/yarn.lock b/yarn.lock
index 24c180817..1ac30daba 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -7873,10 +7873,10 @@ prepend-http@^1.0.0:
   resolved "https://registry.yarnpkg.com/prepend-http/-/prepend-http-1.0.4.tgz#d4f4562b0ce3696e41ac52d0e002e57a635dc6dc"
   integrity sha1-1PRWKwzjaW5BrFLQ4ALlemNdxtw=
 
-prettier@^2.3.2:
-  version "2.4.1"
-  resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.4.1.tgz#671e11c89c14a4cfc876ce564106c4a6726c9f5c"
-  integrity sha512-9fbDAXSBcc6Bs1mZrDYb3XKzDLm4EXXL9sC1LqKP5rZkT6KRr/rf9amVUcODVXgguK/isJz0d0hP72WeaKWsvA==
+prettier@^3.6.2:
+  version "3.6.2"
+  resolved "https://registry.yarnpkg.com/prettier/-/prettier-3.6.2.tgz#ccda02a1003ebbb2bfda6f83a074978f608b9393"
+  integrity sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==
 
 pretty-error@^4.0.0:
   version "4.0.0"