diff --git a/git_sync_filtered/cli.py b/git_sync_filtered/cli.py
index 7e8e27f..ac3d6a1 100644
--- a/git_sync_filtered/cli.py
+++ b/git_sync_filtered/cli.py
@@ -1,50 +1,15 @@
-from fnmatch import translate as glob_translate
 from pathlib import Path
 
 import click
-from pydantic import BaseModel, ConfigDict, FilePath, field_validator
 
 from git_sync_filtered.sync import sync
 
 
-class SyncConfig(BaseModel):
-    model_config = ConfigDict(frozen=True)
-
-    private: str
-    public: str
-    keep: tuple[str, ...]
-    keep_from_file: FilePath | None = None
-    sync_branch: str = "upstream/sync"
-    main_branch: str = "main"
-    private_branch: str = "main"
-    dry_run: bool = False
-    merge: bool = False
-    force: bool = False
-
-    @field_validator("keep", mode="before")
-    @classmethod
-    def ensure_non_empty(cls, v: tuple[str, ...]) -> tuple[str, ...]:
-        if not v:
-            raise ValueError("At least one --keep path required")
-        return v
-
-    @field_validator("keep", mode="after")
-    @classmethod
-    def validate_glob_paths(cls, v: tuple[str, ...]) -> tuple[str, ...]:
-        for path in v:
-            if not path:
-                raise ValueError("Keep path cannot be empty")
-            glob_translate(path)
-        return v
-
-    @field_validator("sync_branch", "main_branch", "private_branch", mode="after")
-    @classmethod
-    def validate_branch_name(cls, v: str) -> str:
-        if not v:
-            raise ValueError("Branch name cannot be empty")
-        if v.startswith("/") or ".." in v:
-            raise ValueError(f"Invalid branch name: {v!r}")
-        return v
+def _validate_branch(name: str) -> None:
+    if not name:
+        raise ValueError("Branch name cannot be empty")
+    if name.startswith("/") or ".." in name:
+        raise ValueError(f"Invalid branch name: {name!r}")
 
 
 @click.command()
@@ -64,6 +29,16 @@ def validate_branch_name(cls, v: str) -> str:
 )
 @click.option("--merge", is_flag=True, help="Merge into main branch after sync")
 @click.option("--force", is_flag=True, help="Force push")
+@click.option(
+    "--marker-prefix",
+    default="synced",
+    help="Prefix for sync marker in commit messages",
+)
+@click.option(
+    "--reset",
+    is_flag=True,
+    help="Reset sync state and re-sync all commits from beginning",
+)
 def main(
     private: str,
     public: str,
@@ -75,11 +50,16 @@ def main(
     dry_run: bool,
     merge: bool,
     force: bool,
+    marker_prefix: str,
+    reset: bool,
 ) -> None:
     """Sync filtered commits from private to public repository."""
 
     try:
-        config = SyncConfig(
+        for branch in (sync_branch, main_branch, private_branch):
+            _validate_branch(branch)
+
+        result = sync(
             private=private,
             public=public,
             keep=keep,
@@ -90,18 +70,8 @@ def main(
             dry_run=dry_run,
             merge=merge,
             force=force,
-        )
-        result = sync(
-            private=config.private,
-            public=config.public,
-            keep=config.keep,
-            keep_from_file=config.keep_from_file,
-            sync_branch=config.sync_branch,
-            main_branch=config.main_branch,
-            private_branch=config.private_branch,
-            dry_run=config.dry_run,
-            merge=config.merge,
-            force=config.force,
+            marker_prefix=marker_prefix,
+            reset=reset,
         )
     except ValueError as e:
         raise click.ClickException(str(e))
diff --git a/git_sync_filtered/lock.py b/git_sync_filtered/lock.py
new file mode 100644
index 0000000..cb81868
--- /dev/null
+++ b/git_sync_filtered/lock.py
@@ -0,0 +1,14 @@
+import git
+
+
+def check_sync_lock(repo: git.Repo, remote_name: str, sync_branch: str) -> bool:
+    """Check if sync is already in progress by checking if sync branch exists in remote.
+
+    Assumes the caller has already fetched the remote. Uses remote_head attribute
+    to match just the branch name (not the full 'remote/branch' ref name).
+    """
+    try:
+        refs = repo.remote(remote_name).refs
+        return sync_branch in [ref.remote_head for ref in refs]
+    except Exception:
+        return False
diff --git a/git_sync_filtered/marker.py b/git_sync_filtered/marker.py
new file mode 100644
index 0000000..47c59e1
--- /dev/null
+++ b/git_sync_filtered/marker.py
@@ -0,0 +1,29 @@
+import re
+
+
+def parse_marker(message: str, prefix: str) -> str | None:
+    """Extract SHA from commit message marker. Returns None if no marker found."""
+    pattern = rf"\[{prefix}:\s*([^\]]+)\]"
+    match = re.search(pattern, message)
+    if match:
+        return match.group(1)
+    return None
+
+
+def append_marker_to_commit(message: str, sha: str, prefix: str) -> str:
+    """Append or update marker in commit message."""
+    marker = f"[{prefix}: {sha}]"
+    pattern = rf"\[{prefix}:\s*[^\]]+\]"
+
+    new_message = re.sub(pattern, "", message)
+    new_message = new_message.rstrip()
+
+    return f"{new_message}\n\n{marker}"
+
+
+def find_last_synced_sha(commit_messages: list[str], prefix: str) -> str | None:
+    """Find the SHA from the most recent commit with a sync marker."""
+    return next(
+        (sha for msg in commit_messages if (sha := parse_marker(msg, prefix))),
+        None,
+    )
diff --git a/git_sync_filtered/sync.py b/git_sync_filtered/sync.py
index 87c2d6d..52ebdd5 100644
--- a/git_sync_filtered/sync.py
+++ b/git_sync_filtered/sync.py
@@ -7,6 +7,13 @@
 import git
 from git_filter_repo import FilteringOptions, RepoFilter
 
+from git_sync_filtered.lock import check_sync_lock
+from git_sync_filtered.marker import (
+    append_marker_to_commit,
+    find_last_synced_sha,
+    parse_marker,
+)
+
 
 class SyncResult(TypedDict):
     paths_to_keep: list[str]
@@ -31,6 +38,7 @@ def collect_paths_to_keep(
 
 
 def run_filter_repo(repo_path: Path | str, paths_to_keep: list[str]) -> None:
+    """Run git-filter-repo to filter repository to only keep specified paths."""
     old_cwd = os.getcwd()
     os.chdir(repo_path)
 
@@ -59,24 +67,17 @@ def push_to_remote(
     else:
         repo.remote("public").set_url(public_url)
 
-    repo.remote("public").fetch()
-
     if dry_run:
-        commits = []
-        for commit in repo.iter_commits(private_branch):
-            commits.append(f"  {commit.hexsha[:8]} {commit.summary}")
-        return commits
-    else:
-        refspec = f"refs/heads/{private_branch}:refs/heads/{sync_branch}"
-        repo.remote("public").push(refspec=refspec, force=force)
-        return []
+        return [
+            f"  {c.hexsha[:8]} {c.summary}" for c in repo.iter_commits(private_branch)
+        ]
 
+    refspec = f"refs/heads/{private_branch}:refs/heads/{sync_branch}"
+    repo.remote("public").push(refspec=refspec, force=force)
+    return []
 
-def merge_into_main(
-    repo: git.Repo,
-    main_branch: str,
-    sync_branch: str,
-) -> bool:
+
+def merge_into_main(repo: git.Repo, main_branch: str, sync_branch: str) -> bool:
     repo.heads[main_branch].checkout()
 
     try:
@@ -91,6 +92,55 @@ def merge_into_main(
         return False
 
 
+def _get_last_synced_sha_from_remote(
+    repo: git.Repo, sync_branch: str, marker_prefix: str
+) -> str | None:
+    """Get the last synced private SHA from the public repo's sync branch commit markers."""
+    try:
+        messages = [
+            c.message.decode("utf-8") if isinstance(c.message, bytes) else c.message
+            for c in repo.iter_commits(f"public/{sync_branch}")
+        ]
+        return find_last_synced_sha(messages, marker_prefix)
+    except Exception:
+        return None
+
+
+def _rewrite_commits_with_markers(
+    repo: git.Repo, branch: str, marker_prefix: str
+) -> None:
+    """Rewrite commit messages to include sync markers for commits not yet marked.
+
+    Processes oldest-to-newest so each amend applies cleanly in sequence.
+    """
+    commits = list(repo.iter_commits(branch))
+
+    if not commits:
+        return
+
+    first_commit = commits[0]
+    with repo.config_writer() as config:
+        config.set_value("user", "name", first_commit.committer.name)
+        config.set_value("user", "email", first_commit.committer.email)
+
+    for commit in reversed(commits):
+        message = (
+            commit.message.decode("utf-8")
+            if isinstance(commit.message, bytes)
+            else commit.message
+        )
+
+        if parse_marker(message, marker_prefix):
+            continue
+
+        new_message = append_marker_to_commit(message, commit.hexsha, marker_prefix)
+
+        try:
+            repo.git.commit(message=new_message, amend=True)
+        except git.GitCommandError:
+            pass
+
+
 def sync(
     private: str,
     public: str,
@@ -102,6 +152,8 @@ def sync(
     dry_run: bool,
     merge: bool,
     force: bool,
+    marker_prefix: str = "synced",
+    reset: bool = False,
 ) -> SyncResult:
     paths_to_keep = collect_paths_to_keep(keep, keep_from_file)
 
@@ -110,25 +162,68 @@ def sync(
 
     with TemporaryDirectory(prefix="git-sync-") as work_dir:
         work_dir_path = Path(work_dir)
+
+        # Step 1: Fetch public state to determine what was last synced
+        last_synced_sha: str | None = None
+        if not dry_run and not reset:
+            probe_path = work_dir_path / "probe"
+            probe_repo = git.Repo.clone_from(private, str(probe_path))
+            probe_repo.create_remote("public", public)
+            try:
+                probe_repo.remote("public").fetch()
+                last_synced_sha = _get_last_synced_sha_from_remote(
+                    probe_repo, sync_branch, marker_prefix
+                )
+            except Exception:  # noqa: BLE001
+                last_synced_sha = None
+
+            lock_branch = f"{sync_branch}-in-progress"
+            if check_sync_lock(probe_repo, "public", lock_branch):
+                raise ValueError(
+                    f"Sync already in progress: {lock_branch} branch exists"
+                )
+
+        # Step 2: Clone the private repo; apply graft for incremental sync
         private_clone = work_dir_path / "private"
         private_repo = git.Repo.clone_from(private, str(private_clone))
 
+        if last_synced_sha:
+            # Graft: treat last_synced_sha as a root so filter-repo only
+            # rewrites commits after it
+            try:
+                private_repo.commit(last_synced_sha)
+                grafts_file = private_clone / ".git" / "info" / "grafts"
+                grafts_file.parent.mkdir(parents=True, exist_ok=True)
+                grafts_file.write_text(f"{last_synced_sha}\n")
+            except Exception:  # noqa: BLE001
+                last_synced_sha = None  # SHA gone; fall back to full sync
+
+        # Step 3: Filter the (possibly grafted) history
         run_filter_repo(str(private_clone), paths_to_keep)
 
+        # Re-open Repo after filter-repo rewrites history
+        private_repo.close()
+        private_repo = git.Repo(private_clone)
+
+        # Step 4: Rewrite commit messages with sync markers
+        _rewrite_commits_with_markers(private_repo, private_branch, marker_prefix)
+
+        # Step 5: Push — force when incremental since SHAs are rewritten by filter-repo
         dry_run_commits = push_to_remote(
-            private_repo, public, sync_branch, private_branch, force, dry_run
+            private_repo,
+            public,
+            sync_branch,
+            private_branch,
+            force=force or bool(last_synced_sha),
+            dry_run=dry_run,
         )
 
+        merge_success: bool | None = None
         if merge and not dry_run:
-            success = merge_into_main(private_repo, main_branch, sync_branch)
-            return {
-                "paths_to_keep": paths_to_keep,
-                "dry_run_commits": dry_run_commits,
-                "merge_success": success,
-            }
+            merge_success = merge_into_main(private_repo, main_branch, sync_branch)
 
         return {
             "paths_to_keep": paths_to_keep,
             "dry_run_commits": dry_run_commits,
-            "merge_success": None,
+            "merge_success": merge_success,
         }
diff --git a/git_sync_filtered/verify.py b/git_sync_filtered/verify.py
new file mode 100644
index 0000000..bcbff77
--- /dev/null
+++ b/git_sync_filtered/verify.py
@@ -0,0 +1,41 @@
+import git
+
+
+def get_file_hashes(
+    repo: git.Repo, paths: list[str], ref: str = "HEAD"
+) -> dict[str, str]:
+    """Get SHA-1 object hashes for files using git ls-tree."""
+    hashes: dict[str, str] = {}
+    for path in paths:
+        result = repo.git.ls_tree("-r", ref, "--", path)
+        if not result:
+            continue
+        for line in result.splitlines():
+            parts = line.split()
+            if len(parts) >= 4:
+                obj_hash = parts[2]
+                file_path = parts[3]
+                hashes[file_path] = obj_hash
+    return hashes
+
+
+def verify_sync_integrity(
+    private_repo: git.Repo,
+    public_repo: git.Repo,
+    paths_to_keep: list[str],
+    private_ref: str = "HEAD",
+    public_ref: str = "HEAD",
+) -> bool:
+    """
+    Verify that synced files in public repo match filtered files from private repo.
+
+    Compares file object hashes between private (filtered) and public repos.
+    Returns True if hashes match, False otherwise.
+    """
+    if not paths_to_keep:
+        return True
+
+    private_hashes = get_file_hashes(private_repo, paths_to_keep, private_ref)
+    public_hashes = get_file_hashes(public_repo, paths_to_keep, public_ref)
+
+    return private_hashes == public_hashes
diff --git a/pyproject.toml b/pyproject.toml
index b617366..635ead3 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -22,12 +22,7 @@ classifiers = [
   "Programming Language :: Python :: 3.14",
 ]
 
-dependencies = [
-  "click>=8.0",
-  "gitpython>=3.1",
-  "git-filter-repo>=2.0",
-  "pydantic>=2.12.5",
-]
+dependencies = ["click>=8.0", "gitpython>=3.1", "git-filter-repo>=2.0"]
 
 [project.optional-dependencies]
 dev = ["pytest", "ruff", "mypy"]
diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py
new file mode 100644
index 0000000..d99df8e
--- /dev/null
+++ b/tests/integration/conftest.py
@@ -0,0 +1,21 @@
+import os
+import subprocess
+from pathlib import Path
+
+import pytest
+
+
+@pytest.fixture
+def git_env() -> dict[str, str]:
+    """Git environment with deterministic author/committer identity."""
+    return {
+        **os.environ,
+        "GIT_AUTHOR_NAME": "Test",
+        "GIT_AUTHOR_EMAIL": "test@test.com",
+        "GIT_COMMITTER_NAME": "Test",
+        "GIT_COMMITTER_EMAIL": "test@test.com",
+    }
+
+
+def run_git(cwd: Path, *args: str, env: dict[str, str] | None = None) -> None:
+    subprocess.run(["git", *args], cwd=cwd, check=True, env=env)
diff --git a/tests/integration/test_idempotency.py b/tests/integration/test_idempotency.py
new file mode 100644
index 0000000..3462072
--- /dev/null
+++ b/tests/integration/test_idempotency.py
@@ -0,0 +1,256 @@
+import os
+import subprocess
+from pathlib import Path
+
+from git_sync_filtered.sync import sync
+
+
+def run_git(cwd: Path, *args: str, env: dict[str, str] | None = None) -> None:
+    subprocess.run(["git", *args], cwd=cwd, check=True, env=env)
+
+
+def test_marker_in_commit_message(tmp_path: Path) -> None:
+    """Verify marker is appended to commit messages after sync."""
+    env = {
+        **os.environ,
+        "GIT_AUTHOR_NAME": "Test",
+        "GIT_AUTHOR_EMAIL": "test@test.com",
+        "GIT_COMMITTER_NAME": "Test",
+        "GIT_COMMITTER_EMAIL": "test@test.com",
+    }
+
+    private_repo = tmp_path / "private_source"
+    private_repo.mkdir()
+    (private_repo / "src").mkdir()
+    (private_repo / "src" / "main.py").write_text("print('hello')")
+
+    run_git(private_repo, "init", env=env)
+    run_git(private_repo, "checkout", "-b", "main", env=env)
+    run_git(private_repo, "add", ".", env=env)
+    run_git(private_repo, "commit", "-m", "initial", env=env)
+
+    public_repo = tmp_path / "public_repo"
+    public_repo.mkdir()
+    run_git(public_repo, "init", "--bare", env=env)
+
+    sync(
+        private=str(private_repo),
+        public=str(public_repo),
+        keep=("src",),
+        keep_from_file=None,
+        sync_branch="upstream/sync",
+        main_branch="main",
+        private_branch="main",
+        dry_run=False,
+        merge=False,
+        force=False,
+    )
+
+    cloned = tmp_path / "check_public"
+    subprocess.run(["git", "clone", str(public_repo), str(cloned)], check=True, env=env)
+    run_git(cloned, "checkout", "upstream/sync", env=env)
+
+    result = subprocess.run(
+        ["git", "log", "--format=%B", "-1"],
+        cwd=cloned,
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+    assert "[synced:" in result.stdout, f"Marker not found in commit: {result.stdout}"
+
+
+def test_idempotent_sync_no_duplicates(tmp_path: Path) -> None:
+    """Running sync twice should not create duplicate commits."""
+    env = {
+        **os.environ,
+        "GIT_AUTHOR_NAME": "Test",
+        "GIT_AUTHOR_EMAIL": "test@test.com",
+        "GIT_COMMITTER_NAME": "Test",
+        "GIT_COMMITTER_EMAIL": "test@test.com",
+    }
+
+    private_repo = tmp_path / "private_source"
+    private_repo.mkdir()
+    (private_repo / "src").mkdir()
+    (private_repo / "src" / "main.py").write_text("print('hello')")
+
+    run_git(private_repo, "init", env=env)
+    run_git(private_repo, "checkout", "-b", "main", env=env)
+    run_git(private_repo, "add", ".", env=env)
+    run_git(private_repo, "commit", "-m", "initial", env=env)
+
+    public_repo = tmp_path / "public_repo"
+    public_repo.mkdir()
+    run_git(public_repo, "init", "--bare", env=env)
+
+    for _ in range(2):
+        sync(
+            private=str(private_repo),
+            public=str(public_repo),
+            keep=("src",),
+            keep_from_file=None,
+            sync_branch="upstream/sync",
+            main_branch="main",
+            private_branch="main",
+            dry_run=False,
+            merge=False,
+            force=False,
+        )
+
+    cloned = tmp_path / "check_public"
+    subprocess.run(["git", "clone", str(public_repo), str(cloned)], check=True, env=env)
+    run_git(cloned, "checkout", "upstream/sync", env=env)
+
+    result = subprocess.run(
+        ["git", "rev-list", "--count", "HEAD"],
+        cwd=cloned,
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+    assert (
+        int(result.stdout.strip()) == 1
+    ), f"Expected 1 commit, got {result.stdout.strip()}"
+
+
+def test_idempotent_sync_new_commits_only(tmp_path: Path) -> None:
+    """Only new commits should be synced on subsequent runs."""
+    env = {
+        **os.environ,
+        "GIT_AUTHOR_NAME": "Test",
+        "GIT_AUTHOR_EMAIL": "test@test.com",
+        "GIT_COMMITTER_NAME": "Test",
+        "GIT_COMMITTER_EMAIL": "test@test.com",
+    }
+
+    private_repo = tmp_path / "private_source"
+    private_repo.mkdir()
+    (private_repo / "src").mkdir()
+    (private_repo / "src" / "main.py").write_text("print('hello')")
+
+    run_git(private_repo, "init", env=env)
+    run_git(private_repo, "checkout", "-b", "main", env=env)
+    run_git(private_repo, "add", ".", env=env)
+    run_git(private_repo, "commit", "-m", "initial", env=env)
+
+    public_repo = tmp_path / "public_repo"
+    public_repo.mkdir()
+    run_git(public_repo, "init", "--bare", env=env)
+
+    sync(
+        private=str(private_repo),
+        public=str(public_repo),
+        keep=("src",),
+        keep_from_file=None,
+        sync_branch="upstream/sync",
+        main_branch="main",
+        private_branch="main",
+        dry_run=False,
+        merge=False,
+        force=False,
+    )
+
+    (private_repo / "src" / "new.py").write_text("print('new')")
+    run_git(private_repo, "add", ".", env=env)
+    run_git(private_repo, "commit", "-m", "add new file", env=env)
+
+    sync(
+        private=str(private_repo),
+        public=str(public_repo),
+        keep=("src",),
+        keep_from_file=None,
+        sync_branch="upstream/sync",
+        main_branch="main",
+        private_branch="main",
+        dry_run=False,
+        merge=False,
+        force=False,
+    )
+
+    cloned = tmp_path / "check_public"
+    subprocess.run(["git", "clone", str(public_repo), str(cloned)], check=True, env=env)
+    run_git(cloned, "checkout", "upstream/sync", env=env)
+
+    result = subprocess.run(
+        ["git", "rev-list", "--count", "HEAD"],
+        cwd=cloned,
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+    assert (
+        int(result.stdout.strip()) == 2
+    ), f"Expected 2 commits, got {result.stdout.strip()}"
+
+
+def test_reset_sync_restarts_from_beginning(tmp_path: Path) -> None:
+    """With reset flag, sync should re-sync all commits and rewrite history."""
+    env = {
+        **os.environ,
+        "GIT_AUTHOR_NAME": "Test",
+        "GIT_AUTHOR_EMAIL": "test@test.com",
+        "GIT_COMMITTER_NAME": "Test",
+        "GIT_COMMITTER_EMAIL": "test@test.com",
+    }
+
+    private_repo = tmp_path / "private_source"
+    private_repo.mkdir()
+    (private_repo / "src").mkdir()
+    (private_repo / "src" / "main.py").write_text("print('hello')")
+
+    run_git(private_repo, "init", env=env)
+    run_git(private_repo, "checkout", "-b", "main", env=env)
+    run_git(private_repo, "add", ".", env=env)
+    run_git(private_repo, "commit", "-m", "initial", env=env)
+
+    public_repo = tmp_path / "public_repo"
+    public_repo.mkdir()
+    run_git(public_repo, "init", "--bare", env=env)
+
+    sync(
+        private=str(private_repo),
+        public=str(public_repo),
+        keep=("src",),
+        keep_from_file=None,
+        sync_branch="upstream/sync",
+        main_branch="main",
+        private_branch="main",
+        dry_run=False,
+        merge=False,
+        force=False,
+    )
+
+    sync(
+        private=str(private_repo),
+        public=str(public_repo),
+        keep=("src",),
+        keep_from_file=None,
+        sync_branch="upstream/sync",
+        main_branch="main",
+        private_branch="main",
+        dry_run=False,
+        merge=False,
+        force=False,
+        reset=True,
+    )
+
+    result = subprocess.run(
+        ["git", "rev-list", "--count", "upstream/sync"],
+        cwd=public_repo,
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+    assert (
+        int(result.stdout.strip()) == 1
+    ), f"Expected 1 commit after reset, got {result.stdout.strip()}"
+
+    log = subprocess.run(
+        ["git", "log", "--format=%B", "-1", "upstream/sync"],
+        cwd=public_repo,
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+    assert "[synced:" in log.stdout, "Marker should be present after reset sync"
diff --git a/tests/integration/test_lock.py b/tests/integration/test_lock.py
new file mode 100644
index 0000000..2a9bd0a
--- /dev/null
+++ b/tests/integration/test_lock.py
@@ -0,0 +1,77 @@
+import subprocess
+from pathlib import Path
+
+from git import Repo
+
+from git_sync_filtered.lock import check_sync_lock
+
+
+def run_git(cwd: Path, *args: str, env: dict[str, str] | None = None) -> None:
+    subprocess.run(["git", *args], cwd=cwd, check=True, env=env)
+
+
+def test_check_sync_lock_integration(tmp_path: Path, git_env: dict[str, str]) -> None:
+    """Check lock returns True when lock branch exists in public repo."""
+    public_repo = tmp_path / "public_repo"
+    public_repo.mkdir()
+    subprocess.run(["git", "init", "--bare"], cwd=public_repo, check=True, env=git_env)
+
+    private_repo = tmp_path / "private_source"
+    private_repo.mkdir()
+    subprocess.run(["git", "init"], cwd=private_repo, check=True, env=git_env)
+
+    (private_repo / "src").mkdir()
+    (private_repo / "src" / "main.py").write_text("print('hello')")
+    run_git(private_repo, "add", ".", env=git_env)
+    run_git(private_repo, "commit", "-m", "initial", env=git_env)
+
+    # Get the current branch name (may be 'master' or 'main' depending on git config)
+    result = subprocess.run(
+        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+        cwd=private_repo,
+        capture_output=True,
+        text=True,
+        env=git_env,
+    )
+    current_branch = result.stdout.strip()
+
+    run_git(private_repo, "remote", "add", "public", str(public_repo), env=git_env)
+    run_git(
+        private_repo,
+        "push",
+        "public",
+        f"{current_branch}:upstream/sync-in-progress",
+        env=git_env,
+    )
+
+    repo = Repo(str(private_repo))
+    repo.remote("public").fetch()
+
+    result = check_sync_lock(repo, "public", "upstream/sync-in-progress")
+
+    assert result is True
+
+
+def test_check_sync_lock_no_branch_integration(
+    tmp_path: Path, git_env: dict[str, str]
+) -> None:
+    """Check lock returns False when lock branch doesn't exist."""
+    public_repo = tmp_path / "public_repo"
+    public_repo.mkdir()
+    subprocess.run(["git", "init", "--bare"], cwd=public_repo, check=True, env=git_env)
+
+    private_repo = tmp_path / "private_source"
+    private_repo.mkdir()
+    subprocess.run(["git", "init"], cwd=private_repo, check=True, env=git_env)
+
+    (private_repo / "src").mkdir()
+    (private_repo / "src" / "main.py").write_text("print('hello')")
+    run_git(private_repo, "add", ".", env=git_env)
+    run_git(private_repo, "commit", "-m", "initial", env=git_env)
+    run_git(private_repo, "remote", "add", "public", str(public_repo), env=git_env)
+
+    repo = Repo(str(private_repo))
+
+    result = check_sync_lock(repo, "public", "upstream/sync")
+
+    assert result is False
diff --git a/tests/integration/test_verify.py b/tests/integration/test_verify.py
new file mode 100644
index 0000000..30ef3e5
--- /dev/null
+++ b/tests/integration/test_verify.py
@@ -0,0 +1,101 @@
+import subprocess
+from pathlib import Path
+
+import git
+
+from git_sync_filtered.sync import sync
+from git_sync_filtered.verify import verify_sync_integrity
+
+
+def run_git(cwd: Path, *args: str, env: dict[str, str] | None = None) -> None:
+    subprocess.run(["git", *args], cwd=cwd, check=True, env=env)
+
+
+def test_verify_sync_integrity_success(tmp_path: Path, git_env: dict[str, str]) -> None:
+    """Hash verification should pass when synced files match."""
+    private_repo = tmp_path / "private_source"
+    private_repo.mkdir()
+    (private_repo / "src").mkdir()
+    (private_repo / "src" / "main.py").write_text("print('hello')")
+
+    run_git(private_repo, "init", env=git_env)
+    run_git(private_repo, "checkout", "-b", "main", env=git_env)
+    run_git(private_repo, "add", ".", env=git_env)
+    run_git(private_repo, "commit", "-m", "initial", env=git_env)
+
+    public_repo = tmp_path / "public_repo"
+    public_repo.mkdir()
+    run_git(public_repo, "init", "--bare", env=git_env)
+
+    sync(
+        private=str(private_repo),
+        public=str(public_repo),
+        keep=("src",),
+        keep_from_file=None,
+        sync_branch="upstream/sync",
+        main_branch="main",
+        private_branch="main",
+        dry_run=False,
+        merge=False,
+        force=False,
+    )
+
+    result = verify_sync_integrity(
+        git.Repo(str(private_repo)),
+        git.Repo(str(public_repo)),
+        ["src"],
+        public_ref="upstream/sync",
+    )
+
+    assert result is True
+
+
+def test_verify_sync_integrity_failure(tmp_path: Path, git_env: dict[str, str]) -> None:
+    """Hash verification should fail when public files have been tampered with."""
+    private_repo = tmp_path / "private_source"
+    private_repo.mkdir()
+    (private_repo / "src").mkdir()
+    (private_repo / "src" / "main.py").write_text("print('hello')")
+
+    run_git(private_repo, "init", env=git_env)
+    run_git(private_repo, "checkout", "-b", "main", env=git_env)
+    run_git(private_repo, "add", ".", env=git_env)
+    run_git(private_repo, "commit", "-m", "initial", env=git_env)
+
+    public_repo = tmp_path / "public_repo"
+    public_repo.mkdir()
+    run_git(public_repo, "init", "--bare", env=git_env)
+
+    sync(
+        private=str(private_repo),
+        public=str(public_repo),
+        keep=("src",),
+        keep_from_file=None,
+        sync_branch="upstream/sync",
+        main_branch="main",
+        private_branch="main",
+        dry_run=False,
+        merge=False,
+        force=False,
+    )
+
+    # Tamper with the public repo
+    checkout = tmp_path / "public_checkout"
+    checkout.mkdir()
+    subprocess.run(
+        ["git", "clone", str(public_repo), str(checkout)], check=True, env=git_env
+    )
+    run_git(checkout, "checkout", "upstream/sync", env=git_env)
+    (checkout / "src" / "main.py").write_text("print('modified')")
+    run_git(checkout, "add", ".", env=git_env)
+    run_git(checkout, "commit", "-m", "tamper", env=git_env)
+    run_git(checkout, "push", "origin", "upstream/sync", env=git_env)
+
+    result = verify_sync_integrity(
+        git.Repo(str(private_repo)),
+        git.Repo(str(public_repo)),
+        ["src"],
+        public_ref="upstream/sync",
+    )
+
+    assert result is False
diff --git a/tests/unit/test_commit_marker.py b/tests/unit/test_commit_marker.py
new file mode 100644
index 0000000..e3087bb
--- /dev/null
+++ b/tests/unit/test_commit_marker.py
@@ -0,0 +1,122 @@
+from git_sync_filtered.marker import (
+    append_marker_to_commit,
+    find_last_synced_sha,
+    parse_marker,
+)
+
+
+def test_find_last_synced_sha_returns_sha_when_marker_found() -> None:
+    """When commit message contains marker, return the SHA."""
+    commit_messages = [
+        "Add feature\n\n[synced: abc123def456]",
+        "Fix bug",
+        "Initial commit",
+    ]
+
+    result = find_last_synced_sha(commit_messages, "synced")
+
+    assert result == "abc123def456"
+
+
+def test_find_last_synced_sha_returns_none_when_no_marker() -> None:
+    """When no commit has marker, return None."""
+    commit_messages = [
+        "Add feature",
+        "Fix bug",
+        "Initial commit",
+    ]
+
+    result = find_last_synced_sha(commit_messages, "synced")
+
+    assert result is None
+
+
+def test_find_last_synced_sha_returns_none_for_empty_list() -> None:
+    """When commit list is empty, return None."""
+    result = find_last_synced_sha([], "synced")
+
+    assert result is None
+
+
+def test_find_last_synced_sha_uses_custom_prefix() -> None:
+    """When custom prefix is used, find marker with that prefix."""
+    commit_messages = [
+        "Add feature\n\n[custom: sha987654321]",
+        "Fix bug",
+    ]
+
+    result = find_last_synced_sha(commit_messages, "custom")
+
+    assert result == "sha987654321"
+
+
+def test_find_last_synced_sha_returns_first_marker() -> None:
+    """When multiple markers exist, return the first one found (most recent)."""
+    commit_messages = [
+        "New feature\n\n[synced: zyx987]",
+        "Old feature\n\n[synced: abc123]",
+    ]
+
+    result = find_last_synced_sha(commit_messages, "synced")
+
+    assert result == "zyx987"
+
+
+def test_parse_marker_extracts_sha() -> None:
+    """Parse marker should extract SHA from commit message."""
+    message = "Add feature\n\n[synced: abc123def456]"
+
+    result = parse_marker(message, "synced")
+
+    assert result == "abc123def456"
+
+
+def test_parse_marker_returns_none_when_no_marker() -> None:
+    """Parse marker returns None when no marker in message."""
+    message = "Add feature"
+
+    result = parse_marker(message, "synced")
+
+    assert result is None
+
+
+def test_append_marker_to_commit_appends_marker() -> None:
+    """Append marker should add marker to end of commit message."""
+    message = "Add new feature"
+    sha = "abc123def456"
+
+    result = append_marker_to_commit(message, sha, "synced")
+
+    assert result == "Add new feature\n\n[synced: abc123def456]"
+
+
+def test_append_marker_to_commit_handles_existing_newline() -> None:
+    """Append marker should handle message that already ends with newline."""
+    message = "Add new feature\n"
+    sha = "abc123def456"
+
+    result = append_marker_to_commit(message, sha, "synced")
+
+    assert result == "Add new feature\n\n[synced: abc123def456]"
+
+
+def test_append_marker_to_commit_handles_multiline() -> None:
+    """Append marker should work with multiline commit messages."""
+    message = "Add new feature\n\nThis is a longer description"
+    sha = "abc123def456"
+
+    result = append_marker_to_commit(message, sha, "synced")
+
+    assert "[synced: abc123def456]" in result
+    assert result.endswith("abc123def456]")
+
+
+def test_append_marker_to_commit_handles_existing_marker() -> None:
+    """When marker already exists, it should be replaced."""
+    message = "Add feature\n\n[synced: oldsha123]"
+    sha = "newsha456"
+
+    result = append_marker_to_commit(message, sha, "synced")
+
+    assert result == "Add feature\n\n[synced: newsha456]"
+    assert "oldsha123" not in result
diff --git a/tests/unit/test_push_to_remote.py b/tests/unit/test_push_to_remote.py
index 9074b8a..3bcc076 100644
--- a/tests/unit/test_push_to_remote.py
+++ b/tests/unit/test_push_to_remote.py
@@ -29,7 +29,7 @@ def test_push_to_remote_creates_remote_when_not_exists(mock_repo: Repo) -> None:
     mock_repo.create_remote.assert_called_once_with(
         "public", "https://github.com/user/public.git"
     )
-    mock_repo.remote("public").fetch.assert_called_once()
+    mock_repo.remote("public").fetch.assert_not_called()
     mock_repo.remote("public").push.assert_called_once()
 
 
diff --git a/tests/unit/test_sync_lock.py b/tests/unit/test_sync_lock.py
new file mode 100644
index 0000000..04cc8ee
--- /dev/null
+++ b/tests/unit/test_sync_lock.py
@@ -0,0 +1,48 @@
+from unittest.mock import MagicMock
+
+import pytest
+from git import Repo
+
+from git_sync_filtered.lock import check_sync_lock
+
+
+def test_check_sync_lock_returns_false_when_no_refs(mock_repo: MagicMock) -> None:
+    """When remote has no refs, check returns False (no lock)."""
+    mock_repo.remote.return_value.refs = []
+
+    result = check_sync_lock(mock_repo, "public", "upstream/sync")
+
+    assert result is False
+
+
+def test_check_sync_lock_returns_true_when_lock_branch_exists(
+    mock_repo: MagicMock,
+) -> None:
+    """When lock branch exists, check returns True (lock held)."""
+    mock_ref = MagicMock()
+    mock_ref.remote_head = "upstream/sync-in-progress"
+    mock_repo.remote.return_value.refs = [mock_ref]
+
+    result = check_sync_lock(mock_repo, "public", "upstream/sync-in-progress")
+
+    assert result is True
+
+
+def test_check_sync_lock_returns_false_when_only_dest_branch_exists(
+    mock_repo: MagicMock,
+) -> None:
+    """Destination branch existing does not count as a lock."""
+    mock_ref = MagicMock()
+    mock_ref.remote_head = "upstream/sync"
+    mock_repo.remote.return_value.refs = [mock_ref]
+
+    result = check_sync_lock(mock_repo, "public", "upstream/sync-in-progress")
+
+    assert result is False
+
+
+@pytest.fixture
+def mock_repo() -> MagicMock:
+    repo = MagicMock(spec=Repo)
+    repo.remote.return_value = MagicMock()
+    return repo
diff --git a/tests/unit/test_verify_sync_integrity.py b/tests/unit/test_verify_sync_integrity.py
new file mode 100644
index 0000000..105dab3
--- /dev/null
+++ b/tests/unit/test_verify_sync_integrity.py
@@ -0,0 +1,70 @@
+from unittest.mock import MagicMock
+
+from git import Repo
+
+from git_sync_filtered.verify import get_file_hashes, verify_sync_integrity
+
+
+def _make_repo(*ls_tree_responses: str) -> MagicMock:
+    """Create a mock Repo whose git.ls_tree returns the given responses in sequence."""
+    repo = MagicMock(spec=Repo)
+    repo.git.ls_tree.side_effect = list(ls_tree_responses)
+    return repo
+
+
+def test_verify_sync_integrity_returns_true_when_hashes_match() -> None:
+    """When file hashes match between repos, verify returns True."""
+    private = _make_repo("100644 blob abc1234 file1.py", "100644 blob def5678 file2.py")
+    public = _make_repo("100644 blob abc1234 file1.py", "100644 blob def5678 file2.py")
+
+    assert verify_sync_integrity(private, public, ["file1.py", "file2.py"]) is True
+
+
+def test_verify_sync_integrity_returns_false_when_hashes_differ() -> None:
+    """When file hashes differ between repos, verify returns False."""
+    private = _make_repo("100644 blob abc1234 file1.py", "100644 blob def5678 file2.py")
+    public = _make_repo("100644 blob abc1234 file1.py", "100644 blob WRONG456 file2.py")
+
+    assert verify_sync_integrity(private, public, ["file1.py", "file2.py"]) is False
+
+
+def test_verify_sync_integrity_handles_missing_file_in_public() -> None:
+    """When a file exists in private but not public, verify returns False."""
+    private = _make_repo("100644 blob abc1234 file1.py", "100644 blob def5678 file2.py")
+    public = _make_repo("100644 blob abc1234 file1.py", "")  # file2.py absent
+
+    assert verify_sync_integrity(private, public, ["file1.py", "file2.py"]) is False
+
+
+def test_verify_sync_integrity_handles_extra_file_in_public() -> None:
+    """When a file exists in public but not private, verify returns False."""
+    private = _make_repo("100644 blob abc1234 file1.py", "")  # file2.py absent
+    public = _make_repo("100644 blob abc1234 file1.py", "100644 blob def5678 file2.py")
+
+    assert verify_sync_integrity(private, public, ["file1.py", "file2.py"]) is False
+
+
+def test_verify_sync_integrity_empty_paths() -> None:
+    """When no paths provided, verify returns True (nothing to compare)."""
+    private = MagicMock(spec=Repo)
+    public = MagicMock(spec=Repo)
+
+    assert verify_sync_integrity(private, public, []) is True
+    private.git.ls_tree.assert_not_called()
+    public.git.ls_tree.assert_not_called()
+
+
+def test_get_file_hashes_parses_ls_tree_output() -> None:
+    """Verify get_file_hashes correctly parses git ls-tree output."""
+    repo = _make_repo("100644 blob abc1234 file1.py", "100644 blob def5678 file2.py")
+
+    hashes = get_file_hashes(repo, ["file1.py", "file2.py"])
+
+    assert hashes == {"file1.py": "abc1234", "file2.py": "def5678"}
+
+
+def test_get_file_hashes_handles_empty_output() -> None:
+    """Verify get_file_hashes handles empty ls-tree output."""
+    repo = _make_repo("")
+
+    assert get_file_hashes(repo, ["nonexistent.py"]) == {}
diff --git a/uv.lock b/uv.lock
index f7de47a..f8eab14 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2,15 +2,6 @@ version = 1
 revision = 3
 requires-python = ">=3.10"
 
-[[package]]
-name = "annotated-types"
-version = "0.7.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
-]
-
 [[package]]
 name = "click"
 version = "8.3.1"
@@ -61,7 +52,6 @@ dependencies = [
     { name = "click" },
     { name = "git-filter-repo" },
     { name = "gitpython" },
-    { name = "pydantic" },
 ]
 
 [package.optional-dependencies]
@@ -82,7 +72,6 @@ requires-dist = [
     { name = "git-filter-repo", specifier = ">=2.0" },
     { name = "gitpython", specifier = ">=3.1" },
     { name = "mypy", marker = "extra == 'dev'" },
-    { name = "pydantic", specifier = ">=2.12.5" },
     { name = "pytest", marker = "extra == 'dev'" },
     { name = "ruff", marker = "extra == 'dev'" },
 ]
@@ -291,139 +280,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
 ]
 
-[[package]]
-name = "pydantic"
-version = "2.12.5"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "annotated-types" },
-    { name = "pydantic-core" },
-    { name = "typing-extensions" },
-    { name = "typing-inspection" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
-]
-
-[[package]]
-name = "pydantic-core"
-version = "2.41.5"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c6/90/32c9941e728d564b411d574d8ee0cf09b12ec978cb22b294995bae5549a5/pydantic_core-2.41.5-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:77b63866ca88d804225eaa4af3e664c5faf3568cea95360d21f4725ab6e07146", size = 2107298, upload-time = "2025-11-04T13:39:04.116Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/a8/61c96a77fe28993d9a6fb0f4127e05430a267b235a124545d79fea46dd65/pydantic_core-2.41.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dfa8a0c812ac681395907e71e1274819dec685fec28273a28905df579ef137e2", size = 1901475, upload-time = "2025-11-04T13:39:06.055Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/b6/338abf60225acc18cdc08b4faef592d0310923d19a87fba1faf05af5346e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5921a4d3ca3aee735d9fd163808f5e8dd6c6972101e4adbda9a4667908849b97", size = 1918815, upload-time = "2025-11-04T13:39:10.41Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/1c/2ed0433e682983d8e8cba9c8d8ef274d4791ec6a6f24c58935b90e780e0a/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e25c479382d26a2a41b7ebea1043564a937db462816ea07afa8a44c0866d52f9", size = 2065567, upload-time = "2025-11-04T13:39:12.244Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/24/cf84974ee7d6eae06b9e63289b7b8f6549d416b5c199ca2d7ce13bbcf619/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f547144f2966e1e16ae626d8ce72b4cfa0caedc7fa28052001c94fb2fcaa1c52", size = 2230442, upload-time = "2025-11-04T13:39:13.962Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/21/4e287865504b3edc0136c89c9c09431be326168b1eb7841911cbc877a995/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f52298fbd394f9ed112d56f3d11aabd0d5bd27beb3084cc3d8ad069483b8941", size = 2350956, upload-time = "2025-11-04T13:39:15.889Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/76/7727ef2ffa4b62fcab916686a68a0426b9b790139720e1934e8ba797e238/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:100baa204bb412b74fe285fb0f3a385256dad1d1879f0a5cb1499ed2e83d132a", size = 2068253, upload-time = "2025-11-04T13:39:17.403Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/8c/a4abfc79604bcb4c748e18975c44f94f756f08fb04218d5cb87eb0d3a63e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:05a2c8852530ad2812cb7914dc61a1125dc4e06252ee98e5638a12da6cc6fb6c", size = 2177050, upload-time = "2025-11-04T13:39:19.351Z" },
-    { url = "https://files.pythonhosted.org/packages/67/b1/de2e9a9a79b480f9cb0b6e8b6ba4c50b18d4e89852426364c66aa82bb7b3/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:29452c56df2ed968d18d7e21f4ab0ac55e71dc59524872f6fc57dcf4a3249ed2", size = 2147178, upload-time = "2025-11-04T13:39:21Z" },
-    { url = "https://files.pythonhosted.org/packages/16/c1/dfb33f837a47b20417500efaa0378adc6635b3c79e8369ff7a03c494b4ac/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:d5160812ea7a8a2ffbe233d8da666880cad0cbaf5d4de74ae15c313213d62556", size = 2341833, upload-time = "2025-11-04T13:39:22.606Z" },
-    { url = "https://files.pythonhosted.org/packages/47/36/00f398642a0f4b815a9a558c4f1dca1b4020a7d49562807d7bc9ff279a6c/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:df3959765b553b9440adfd3c795617c352154e497a4eaf3752555cfb5da8fc49", size = 2321156, upload-time = "2025-11-04T13:39:25.843Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/70/cad3acd89fde2010807354d978725ae111ddf6d0ea46d1ea1775b5c1bd0c/pydantic_core-2.41.5-cp310-cp310-win32.whl", hash = "sha256:1f8d33a7f4d5a7889e60dc39856d76d09333d8a6ed0f5f1190635cbec70ec4ba", size = 1989378, upload-time = "2025-11-04T13:39:27.92Z" },
-    { url = "https://files.pythonhosted.org/packages/76/92/d338652464c6c367e5608e4488201702cd1cbb0f33f7b6a85a60fe5f3720/pydantic_core-2.41.5-cp310-cp310-win_amd64.whl", hash = "sha256:62de39db01b8d593e45871af2af9e497295db8d73b085f6bfd0b18c83c70a8f9", size = 2013622, upload-time = "2025-11-04T13:39:29.848Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" },
-    { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" },
-    { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" },
-    { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" },
-    { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" },
-    { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" },
-    { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },
-    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
-    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
-    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
-    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
-    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
-    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },
-    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },
-    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
-    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
-    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
-    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
-    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
-    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
-    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
-    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
-    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
-    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
-    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
-    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
-    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
-    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
-    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
-    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
-    { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" },
-    { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" },
-    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/b0/1a2aa41e3b5a4ba11420aba2d091b2d17959c8d1519ece3627c371951e73/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b5819cd790dbf0c5eb9f82c73c16b39a65dd6dd4d1439dcdea7816ec9adddab8", size = 2103351, upload-time = "2025-11-04T13:43:02.058Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/ee/31b1f0020baaf6d091c87900ae05c6aeae101fa4e188e1613c80e4f1ea31/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5a4e67afbc95fa5c34cf27d9089bca7fcab4e51e57278d710320a70b956d1b9a", size = 1925363, upload-time = "2025-11-04T13:43:05.159Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/89/ab8e86208467e467a80deaca4e434adac37b10a9d134cd2f99b28a01e483/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ece5c59f0ce7d001e017643d8d24da587ea1f74f6993467d85ae8a5ef9d4f42b", size = 2135615, upload-time = "2025-11-04T13:43:08.116Z" },
-    { url = "https://files.pythonhosted.org/packages/99/0a/99a53d06dd0348b2008f2f30884b34719c323f16c3be4e6cc1203b74a91d/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:16f80f7abe3351f8ea6858914ddc8c77e02578544a0ebc15b4c2e1a0e813b0b2", size = 2175369, upload-time = "2025-11-04T13:43:12.49Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/94/30ca3b73c6d485b9bb0bc66e611cff4a7138ff9736b7e66bcf0852151636/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:33cb885e759a705b426baada1fe68cbb0a2e68e34c5d0d0289a364cf01709093", size = 2144218, upload-time = "2025-11-04T13:43:15.431Z" },
-    { url = "https://files.pythonhosted.org/packages/87/57/31b4f8e12680b739a91f472b5671294236b82586889ef764b5fbc6669238/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:c8d8b4eb992936023be7dee581270af5c6e0697a8559895f527f5b7105ecd36a", size = 2329951, upload-time = "2025-11-04T13:43:18.062Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/73/3c2c8edef77b8f7310e6fb012dbc4b8551386ed575b9eb6fb2506e28a7eb/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:242a206cd0318f95cd21bdacff3fcc3aab23e79bba5cac3db5a841c9ef9c6963", size = 2318428, upload-time = "2025-11-04T13:43:20.679Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/02/8559b1f26ee0d502c74f9cca5c0d2fd97e967e083e006bbbb4e97f3a043a/pydantic_core-2.41.5-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d3a978c4f57a597908b7e697229d996d77a6d3c94901e9edee593adada95ce1a", size = 2147009, upload-time = "2025-11-04T13:43:23.286Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" },
-    { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" },
-    { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" },
-    { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" },
-    { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" },
-]
-
 [[package]]
 name = "pygments"
 version = "2.19.2"
@@ -547,15 +403,3 @@ sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac8
 wheels = [
     { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
 ]
-
-[[package]]
-name = "typing-inspection"
-version = "0.4.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
-]