@@ -7,6 +7,9 @@
 import re
 import shutil
 import subprocess
+from urllib.error import HTTPError
+from urllib.parse import quote
+from urllib.request import Request, urlopen
 
 
 def without_po_timestamps(content):
@@ -86,22 +89,68 @@ def require_catalogs(root, catalogs):
         raise FileNotFoundError(f"Missing PO catalogs in {root}: {', '.join(missing)}")
 
 
-def sync(source, destination, language):
+def resource_exists(resource):
+    """Only a resource-level 404 permits skipping an absent download."""
+    request = Request(
+        "https://rest.api.transifex.com/resources/" + quote(resource, safe=":"),
+        headers={"Authorization": f"Bearer {os.environ['TX_TOKEN']}"},
+    )
+    try:
+        with urlopen(request, timeout=30):
+            return True
+    except HTTPError as error:
+        error.close()
+        if error.code == 404:
+            return False
+        raise
+
+
+def sync(source, destination, language, *, skip_missing_resources=False):
     config = source / ".tx/config"
     catalogs = active_catalogs(config)
     downloaded = source / language / "LC_MESSAGES"
-    require_catalogs(downloaded, catalogs)
+    skipped = set()
+    filtered_config = configparser.ConfigParser(interpolation=None)
+    if skip_missing_resources:
+        filtered_config.read(config, encoding="utf-8")
+        # Check every missing download before modifying the repository. Missing
+        # translations of existing resources (or API errors) must still fail.
+        for section in filtered_config.sections():
+            if section == "main":
+                continue
+            path = Path(PurePosixPath(
+                filtered_config[section]["source_file"]
+            ).relative_to("pot").with_suffix(".po"))
+            if not (downloaded / path).is_file() and not resource_exists(section):
+                skipped.add(path)
+                if not (destination / path).is_file():
+                    filtered_config.remove_section(section)
+                print(f"Skipped unavailable Transifex resource: {section} ({path})")
+    incoming = [path for path in catalogs if path not in skipped]
+    require_catalogs(downloaded, incoming)
+    if not incoming:
+        raise ValueError("No PO catalogs downloaded; refusing to sync")
+    # Keep existing translations of temporarily unavailable resources. New
+    # resources without a PO must not enter the config used by the merge job.
+    catalogs = [
+        path for path in catalogs
+        if path not in skipped or (destination / path).is_file()
+    ]
     obsolete = set(tracked_catalogs(destination)) - set(catalogs)
 
-    for path in catalogs:
+    for path in incoming:
         target = destination / path
         target.parent.mkdir(parents=True, exist_ok=True)
         shutil.copyfile(downloaded / path, target)
     for path in sorted(obsolete):
         (destination / path).unlink(missing_ok=True)
         print(f"Removed obsolete catalog: {path}")
     (destination / ".tx").mkdir(exist_ok=True)
-    shutil.copyfile(config, destination / ".tx/config")
+    if skipped:
+        with (destination / ".tx/config").open("w", encoding="utf-8") as stream:
+            filtered_config.write(stream)
+    else:
+        shutil.copyfile(config, destination / ".tx/config")
 
 
 def merge(source, destination):
@@ -131,14 +180,19 @@ def main():
     sync_parser.add_argument("source", type=Path)
     sync_parser.add_argument("destination", type=Path)
     sync_parser.add_argument("--language", default="ja")
+    sync_parser.add_argument(
+        "--skip-missing-resources", action="store_true",
+        help="skip missing downloads only for resources returning 404",
+    )
     merge_parser = commands.add_parser("merge")
     merge_parser.add_argument("source", type=Path)
     merge_parser.add_argument("destination", type=Path)
     restore_parser = commands.add_parser("restore-timestamp-only")
     restore_parser.add_argument("root", type=Path)
     args = parser.parse_args()
     if args.command == "sync":
-        sync(args.source, args.destination, args.language)
+        sync(args.source, args.destination, args.language,
+             skip_missing_resources=args.skip_missing_resources)
     elif args.command == "merge":
         merge(args.source, args.destination)
     else:
 
@@ -35,4 +35,6 @@ sphinx-intl update-txconfig-resources -p pot -d . --transifex-organization-name
 tx pull -l "${LANGUAGE}" -t --use-git-timestamps
 
 # Validate the download before copying catalogs or removing obsolete files.
-python "${ROOTDIR}/scripts/translations.py" sync "${WORKDIR}" "${ROOTDIR}" --language "${LANGUAGE}"
+# Newly generated POTs may not have a Transifex resource yet.
+python "${ROOTDIR}/scripts/translations.py" sync "${WORKDIR}" "${ROOTDIR}" \
+  --language "${LANGUAGE}" --skip-missing-resources
@@ -5,6 +5,8 @@
 import sys
 import tempfile
 import unittest
+from unittest import mock
+from urllib.error import HTTPError, URLError
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
 import translations
@@ -191,6 +193,105 @@ def test_incomplete_download_does_not_change_repository(self):
         self.assertEqual(config_before, (self.destination / ".tx/config").read_bytes())
         self.assertFalse((self.destination / "builtins/functions.po").exists())
 
+    def test_sync_skips_unregistered_resource_and_picks_it_up_later(self):
+        catalogs = ["bugs.po", "c-api/pyexpat.po"]
+        write_config(self.source, catalogs)
+        download = self.source / "ja/LC_MESSAGES"
+        write_po(download, "bugs.po", "新しい訳")
+        obsolete = write_po(self.destination, "removed.po", "古い訳")
+        self.track()
+
+        with mock.patch.object(translations, "resource_exists", return_value=False) as exists:
+            translations.sync(self.source, self.destination, "ja",
+                              skip_missing_resources=True)
+        exists.assert_called_once_with("resource1")
+        self.assertFalse(obsolete.exists())
+        self.assertFalse((self.destination / "c-api/pyexpat.po").exists())
+        self.assertEqual(translations.active_catalogs(self.destination / ".tx/config"),
+                         [Path("bugs.po")])
+        translations.require_catalogs(
+            self.destination, translations.active_catalogs(self.destination / ".tx/config")
+        )
+        # The generated source config remains complete for subsequent runs.
+        self.assertEqual(translations.active_catalogs(self.source / ".tx/config"),
+                         [Path(path) for path in catalogs])
+        write_po(download, "c-api/pyexpat.po", "追加された訳")
+        with mock.patch.object(translations, "resource_exists") as exists:
+            translations.sync(self.source, self.destination, "ja",
+                              skip_missing_resources=True)
+        exists.assert_not_called()
+        self.assertEqual((download / "c-api/pyexpat.po").read_bytes(),
+                         (self.destination / "c-api/pyexpat.po").read_bytes())
+
+    def test_sync_preserves_existing_po_for_unavailable_resource(self):
+        catalogs = ["bugs.po", "c-api/pyexpat.po"]
+        write_config(self.source, catalogs)
+        write_po(self.source / "ja/LC_MESSAGES", "bugs.po", "新しい訳")
+        old = write_po(self.destination, "c-api/pyexpat.po", "既存の訳")
+        self.track()
+        before = old.read_bytes()
+        with mock.patch.object(translations, "resource_exists", return_value=False):
+            translations.sync(self.source, self.destination, "ja",
+                              skip_missing_resources=True)
+        self.assertEqual(old.read_bytes(), before)
+        self.assertEqual(translations.active_catalogs(self.destination / ".tx/config"),
+                         [Path(path) for path in catalogs])
+
+    def test_skip_does_not_hide_incomplete_download_or_api_failure(self):
+        write_config(self.source, ["bugs.po", "new.po", "missing.po"])
+        write_po(self.source / "ja/LC_MESSAGES", "bugs.po", "新しい訳")
+        write_config(self.destination, ["old.po"])
+        old = write_po(self.destination, "old.po", "既存の訳")
+        self.track()
+        before = old.read_bytes()
+        config_before = (self.destination / ".tx/config").read_bytes()
+        for outcome, error in [(True, FileNotFoundError),
+                               (URLError("offline"), URLError)]:
+            with self.subTest(outcome=outcome):
+                with mock.patch.object(translations, "resource_exists",
+                                       side_effect=[False, outcome]):
+                    with self.assertRaises(error):
+                        translations.sync(self.source, self.destination, "ja",
+                                          skip_missing_resources=True)
+                self.assertEqual(old.read_bytes(), before)
+                self.assertEqual((self.destination / ".tx/config").read_bytes(),
+                                 config_before)
+                self.assertFalse((self.destination / "bugs.po").exists())
+
+    def test_skip_refuses_empty_download(self):
+        write_config(self.source, ["new.po"])
+        old = write_po(self.destination, "old.po", "既存の訳")
+        self.track()
+        with mock.patch.object(translations, "resource_exists", return_value=False):
+            with self.assertRaisesRegex(ValueError, "No PO catalogs downloaded"):
+                translations.sync(self.source, self.destination, "ja",
+                                  skip_missing_resources=True)
+        self.assertTrue(old.exists())
+        self.assertFalse((self.destination / ".tx/config").exists())
+
+    def test_resource_exists_only_skips_404(self):
+        resource = "o:python-doc:p:python-newest:r:c-api--pyexpat"
+        with mock.patch.dict(translations.os.environ, {"TX_TOKEN": "test-token"}):
+            with mock.patch.object(translations, "urlopen") as open_url:
+                self.assertTrue(translations.resource_exists(resource))
+                request = open_url.call_args.args[0]
+                self.assertEqual(request.full_url,
+                                 "https://rest.api.transifex.com/resources/" + resource)
+                self.assertEqual(request.get_header("Authorization"), "Bearer test-token")
+                self.assertEqual(open_url.call_args.kwargs, {"timeout": 30})
+            for code in [404, 401, 403, 429, 500]:
+                with self.subTest(code=code):
+                    error = HTTPError("https://rest.api.transifex.com/", code, "error", {}, None)
+                    with mock.patch.object(translations, "urlopen", side_effect=error):
+                        if code == 404:
+                            self.assertFalse(translations.resource_exists(resource))
+                        else:
+                            with self.assertRaises(HTTPError):
+                                translations.resource_exists(resource)
+            with mock.patch.object(translations, "urlopen", side_effect=TimeoutError):
+                with self.assertRaises(TimeoutError):
+                    translations.resource_exists(resource)
+
     def test_empty_config_does_not_delete_catalogs(self):
         write_config(self.source, [])
         old = write_po(self.destination, "library/functions.po", "古い訳")