Add R2 dual-storage adapter and resilient legacy large-document wait

.env.example

@@ -19,11 +19,18 @@ ASSIGNMENT_TITLE=HTLLP notes
 # Playwright
 PLAYWRIGHT_HEADLESS=true
 
-# Storage buckets
-INPUT_BUCKET=turnitin-inputs
-REPORT_BUCKET=turnitin-reports
-DIAGNOSTICS_BUCKET=turnitin-diagnostics
-SESSION_BUCKET=turnitin-sessions
+# Object storage. Existing plain paths continue to read from Supabase after
+# switching new writes to R2.
+STORAGE_PROVIDER=supabase
+INPUT_BUCKET=relv-turnitin-inputs
+REPORT_BUCKET=relv-turnitin-reports
+DIAGNOSTICS_BUCKET=relv-turnitin-diagnostics
+SESSION_BUCKET=relv-turnitin-sessions
+R2_ACCOUNT_ID=
+R2_ACCESS_KEY_ID=
+R2_SECRET_ACCESS_KEY=
+R2_ENDPOINT=https://ACCOUNT_ID.r2.cloudflarestorage.com
+R2_REGION=auto
 
 # Cron intervals (minutes)
 QUOTA_CHECK_INTERVAL=30

package-lock.json

@@ -8,14 +8,19 @@
       "name": "turnitin-worker",
       "version": "1.0.0",
       "dependencies": {
+        "@aws-sdk/client-s3": "^3.1089.0",
+        "@aws-sdk/s3-request-presigner": "^3.1089.0",
         "@supabase/supabase-js": "^2.49.0",
+        "adm-zip": "^0.6.0",
         "dotenv": "^16.4.5",
         "express": "^4.21.0",
         "multer": "^1.4.5-lts.1",
         "node-cron": "^3.0.3",
+        "pdf-lib": "^1.17.1",
         "playwright": "^1.49.0"
       },
       "devDependencies": {
+        "@types/adm-zip": "^0.5.8",
         "@types/express": "^5.0.0",
         "@types/multer": "^1.4.12",
         "@types/node": "^22.0.0",
@@ -27,6 +32,331 @@
         "node": ">=20"
       }
     },
+    "node_modules/@aws-sdk/checksums": {
+      "version": "3.1000.18",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/checksums/-/checksums-3.1000.18.tgz",
+      "integrity": "sha512-IImkbEyXdV6/uaF5r6Wkk+8718mQw1ll83j0a4a30R3JM/rHVFdWAiT4jtJpFjJiIwM/oJ6SxIxr0z2TaQUGqw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/client-s3": {
+      "version": "3.1089.0",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/client-s3/-/client-s3-3.1089.0.tgz",
+      "integrity": "sha512-Sc+JOtNeP+v+XdP9Rb4Hh+uhiNO2hh/CZQbKYooNakhOIgK6/K0cjoDCEGeFmkG0vf2DopTmSctzKlcKwy1BPw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/checksums": "^3.1000.18",
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/credential-provider-node": "^3.972.70",
+        "@aws-sdk/middleware-sdk-s3": "^3.972.64",
+        "@aws-sdk/signature-v4-multi-region": "^3.996.41",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/fetch-http-handler": "^5.6.6",
+        "@smithy/node-http-handler": "^4.9.6",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/core": {
+      "version": "3.975.3",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/core/-/core-3.975.3.tgz",
+      "integrity": "sha512-7ur3kCKuvPLqlsZ2XlvnNBVQ7KkpSu6Y6dOTwSPHLrFpTEfZM8isLBJc4cgv96WB7GifeVM436mpycwxBd2vEA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/types": "^3.974.2",
+        "@aws-sdk/xml-builder": "^3.972.36",
+        "@aws/lambda-invoke-store": "^0.3.0",
+        "@smithy/core": "^3.29.4",
+        "@smithy/signature-v4": "^5.6.5",
+        "@smithy/types": "^4.16.1",
+        "bowser": "^2.11.0",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-env": {
+      "version": "3.972.59",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-env/-/credential-provider-env-3.972.59.tgz",
+      "integrity": "sha512-Ny5e4Mfh3QPmiAc0AiUe+cbTXDlxkU3Rc+EpWOfyWeWEy6yp7Fa1KmfNeCc+1a8by9zQ9gtohmiQUkMPScF3ng==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-http": {
+      "version": "3.972.61",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-http/-/credential-provider-http-3.972.61.tgz",
+      "integrity": "sha512-8jAjgStl5Ytq4+HF3X/9f+EmRinaRbGRRtQGktlPfBRVx73H+R1y48vIeXerQtYGFaUqkEp3fT6jP854rVO2yQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/fetch-http-handler": "^5.6.6",
+        "@smithy/node-http-handler": "^4.9.6",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-ini": {
+      "version": "3.973.4",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-ini/-/credential-provider-ini-3.973.4.tgz",
+      "integrity": "sha512-e6ZvVsj90aRALf1kHP+J4iqC1496ZpVgqI/+u0LJ5HL7q7ATauGy4gdDvRCP13L1pN/fMiZLah162PGIYkbUVQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/credential-provider-env": "^3.972.59",
+        "@aws-sdk/credential-provider-http": "^3.972.61",
+        "@aws-sdk/credential-provider-login": "^3.972.66",
+        "@aws-sdk/credential-provider-process": "^3.972.59",
+        "@aws-sdk/credential-provider-sso": "^3.973.3",
+        "@aws-sdk/credential-provider-web-identity": "^3.972.65",
+        "@aws-sdk/nested-clients": "^3.997.33",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/credential-provider-imds": "^4.4.9",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-login": {
+      "version": "3.972.66",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-login/-/credential-provider-login-3.972.66.tgz",
+      "integrity": "sha512-g2fsqm87r/nKthLZ0VkkDBElkGg0PvSa8d97HQ6EilMbJTZ6hxa8FxkSZyJfgPfFdZn0TTmkOffQmTSUcAHIng==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/nested-clients": "^3.997.33",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-node": {
+      "version": "3.972.70",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-node/-/credential-provider-node-3.972.70.tgz",
+      "integrity": "sha512-3xzvkGdykBunxqh8WudmUpSyLWvIhfI6aBQo1b5rb3mDO5mNLadK+0hiI0qBQBMVynJbfLO+Ajy9dztMwy9O8w==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/credential-provider-env": "^3.972.59",
+        "@aws-sdk/credential-provider-http": "^3.972.61",
+        "@aws-sdk/credential-provider-ini": "^3.973.4",
+        "@aws-sdk/credential-provider-process": "^3.972.59",
+        "@aws-sdk/credential-provider-sso": "^3.973.3",
+        "@aws-sdk/credential-provider-web-identity": "^3.972.65",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/credential-provider-imds": "^4.4.9",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-process": {
+      "version": "3.972.59",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-process/-/credential-provider-process-3.972.59.tgz",
+      "integrity": "sha512-DlZF2/MhLlatDdlrIy3CUCpfdbLrKx+3SMjVo+WyHnPpwzkc/M3vwAHw4OVJf7DMvO+4vfRqSCMc/E9I1auN0g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-sso": {
+      "version": "3.973.3",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-sso/-/credential-provider-sso-3.973.3.tgz",
+      "integrity": "sha512-hmdDHoy2G5Es2e8IgelNMYUuSQI6uCIAKZMJ2u2PdKDhxvbk1uWD/g4+R7R5c/tJfKEB1+KjjWiaoCr/S+ZTiQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/nested-clients": "^3.997.33",
+        "@aws-sdk/token-providers": "3.1088.0",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-web-identity": {
+      "version": "3.972.65",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-web-identity/-/credential-provider-web-identity-3.972.65.tgz",
+      "integrity": "sha512-gHQb/Kt0chjk/JQDa/GJDqmAvEuVn8n7z10wK2h0LFM9TUDRkohgOO4aEF+s2sBLM0br7Cl5W6P7phgjrrJvLQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/nested-clients": "^3.997.33",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/middleware-sdk-s3": {
+      "version": "3.972.64",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/middleware-sdk-s3/-/middleware-sdk-s3-3.972.64.tgz",
+      "integrity": "sha512-RBi43anhDBUv+HCfxCOXwGOE7GmT4n7ChV04Mwr22RhXTNcamW/iWnJlOotDPCZSrJ4dEvhZSiWWQMwLX+ZhFA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/signature-v4-multi-region": "^3.996.41",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/nested-clients": {
+      "version": "3.997.33",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/nested-clients/-/nested-clients-3.997.33.tgz",
+      "integrity": "sha512-dVZOroI/r3/ENvqNGgjMPul+jjlz9GddfVusgTXlVjfZj5isibOxecLkGQbRPp8XOuX+RAfjXLFgPkD1JS5xrw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/signature-v4-multi-region": "^3.996.41",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/fetch-http-handler": "^5.6.6",
+        "@smithy/node-http-handler": "^4.9.6",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/s3-request-presigner": {
+      "version": "3.1089.0",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/s3-request-presigner/-/s3-request-presigner-3.1089.0.tgz",
+      "integrity": "sha512-NYLT340eRdqv8XIUEIEWcIYICDxBGxpgdyQ9veBkW5XxlRDNn19IZ8b46ddec+HBQea/18W+/IfogCqbac3CGQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/signature-v4-multi-region": "^3.996.41",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/signature-v4-multi-region": {
+      "version": "3.996.41",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/signature-v4-multi-region/-/signature-v4-multi-region-3.996.41.tgz",
+      "integrity": "sha512-QMUytg+FQMGouc8gHS00KoYih3+N6cqmVI/pQGOIo7Nr7OpQaiXjSYOuL+vsPZ1tymY4LAQ8MYcHJmws5LRxng==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/signature-v4": "^5.6.5",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/token-providers": {
+      "version": "3.1088.0",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/token-providers/-/token-providers-3.1088.0.tgz",
+      "integrity": "sha512-4ObatWt2qpJg5FBk4LOOKrTQYzaqeewAtdO3r9ZO8lH9YqLtpTzLyIdy0mJ+nVdfYOnqISkKNfmzP22bNDhwyw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/nested-clients": "^3.997.33",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/types": {
+      "version": "3.974.2",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/types/-/types-3.974.2.tgz",
+      "integrity": "sha512-3W6IUtSxFbH6X7Wb7DzGCV5QiFQsd0g8bOfntpmDxQlzBoKWUMBu/JPQR0DwkE+Hpnxd6db1tXbOwdeHddG6cA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/xml-builder": {
+      "version": "3.972.36",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/xml-builder/-/xml-builder-3.972.36.tgz",
+      "integrity": "sha512-RdGmS1GLrtaTOLE1ElSluMldNrpk9Emq6uYs8SS8iHlu5xTAmM9rRkM91o48+rIRryBtyO9t+uLYCoMG6jVMVA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws/lambda-invoke-store": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/@aws/lambda-invoke-store/-/lambda-invoke-store-0.3.0.tgz",
+      "integrity": "sha512-sl4Bm6yiMNYrZKkqqDFWN0UfnWhlS8ivKxrYl+6t0gCLrqr8y3B2IqZZbFRkfaVVp7C/baApyh71P+LeE1A2sQ==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
     "node_modules/@esbuild/aix-ppc64": {
       "version": "0.28.1",
       "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.1.tgz",
@@ -469,6 +799,105 @@
         "node": ">=18"
       }
     },
+    "node_modules/@pdf-lib/standard-fonts": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/@pdf-lib/standard-fonts/-/standard-fonts-1.0.0.tgz",
+      "integrity": "sha512-hU30BK9IUN/su0Mn9VdlVKsWBS6GyhVfqjwl1FjZN4TxP6cCw0jP2w7V3Hf5uX7M0AZJ16vey9yE0ny7Sa59ZA==",
+      "license": "MIT",
+      "dependencies": {
+        "pako": "^1.0.6"
+      }
+    },
+    "node_modules/@pdf-lib/upng": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@pdf-lib/upng/-/upng-1.0.1.tgz",
+      "integrity": "sha512-dQK2FUMQtowVP00mtIksrlZhdFXQZPC+taih1q4CvPZ5vqdxR/LKBaFg0oAfzd1GlHZXXSPdQfzQnt+ViGvEIQ==",
+      "license": "MIT",
+      "dependencies": {
+        "pako": "^1.0.10"
+      }
+    },
+    "node_modules/@smithy/core": {
+      "version": "3.29.5",
+      "resolved": "https://registry.npmjs.org/@smithy/core/-/core-3.29.5.tgz",
+      "integrity": "sha512-i0dk2t5B+CwV/dcJdUHILYkOQF5lof8f44dFCfDWToGCxjT9YQ+CgHqTAvJxzc3+zqQwm2QtVoJ5IqiNar/CnQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@smithy/credential-provider-imds": {
+      "version": "4.4.10",
+      "resolved": "https://registry.npmjs.org/@smithy/credential-provider-imds/-/credential-provider-imds-4.4.10.tgz",
+      "integrity": "sha512-MJenAe4OKRZUo1LdYYFDCsSHxaHvInIU/z52GsheO9vl1/VSySVCr0zkyKD6TFiGkSUaWGxvKZ/70OvgUZR5HQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/core": "^3.29.5",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@smithy/fetch-http-handler": {
+      "version": "5.6.7",
+      "resolved": "https://registry.npmjs.org/@smithy/fetch-http-handler/-/fetch-http-handler-5.6.7.tgz",
+      "integrity": "sha512-3zpg8yqqyXzoK2TsRDdkqVOj2RDBFfLXwCczOZ5c7TWB4eiaebfSCsbMjDPYB3PJ9ihV62QaeadZ+wLadZtNGA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/core": "^3.29.5",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@smithy/node-http-handler": {
+      "version": "4.9.7",
+      "resolved": "https://registry.npmjs.org/@smithy/node-http-handler/-/node-http-handler-4.9.7.tgz",
+      "integrity": "sha512-wCU8HCLjAtAVqxxe0j2xff9LcEPw3yjBbg5IdQDIYFnxnPxbxcSLc7rgex7kqm9L/WYOnJEgaWQlfDkZleozMA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/core": "^3.29.5",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@smithy/signature-v4": {
+      "version": "5.6.6",
+      "resolved": "https://registry.npmjs.org/@smithy/signature-v4/-/signature-v4-5.6.6.tgz",
+      "integrity": "sha512-efP6DN3UTFrzIsGO42/xcabv8jU7+9nwEdphFUH7yL0k010ERyAWaO41KFQIDLcFZLZ8xzIQr4wplFxNzslSGQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/core": "^3.29.5",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@smithy/types": {
+      "version": "4.16.1",
+      "resolved": "https://registry.npmjs.org/@smithy/types/-/types-4.16.1.tgz",
+      "integrity": "sha512-0JFs3V2y2M9tKW5na/qxe69Zv+uxLMO7QBbhxF/FHu/Gp2NFZAAL9tWl9PU02xxo07pb3G9FTyjNc6D5uZrJIg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
     "node_modules/@supabase/auth-js": {
       "version": "2.110.0",
       "resolved": "https://registry.npmjs.org/@supabase/auth-js/-/auth-js-2.110.0.tgz",
@@ -553,6 +982,16 @@
         "node": ">=22.0.0"
       }
     },
+    "node_modules/@types/adm-zip": {
+      "version": "0.5.8",
+      "resolved": "https://registry.npmjs.org/@types/adm-zip/-/adm-zip-0.5.8.tgz",
+      "integrity": "sha512-RVVH7QvZYbN+ihqZ4kX/dMiowf6o+Jk1fNwiSdx0NahBJLU787zkULhGhJM8mf/obmLGmgdMM0bXsQTmyfbR7Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
     "node_modules/@types/body-parser": {
       "version": "1.19.6",
       "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.6.tgz",
@@ -681,6 +1120,15 @@
         "node": ">= 0.6"
       }
     },
+    "node_modules/adm-zip": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/adm-zip/-/adm-zip-0.6.0.tgz",
+      "integrity": "sha512-XleryMhbuksdKtofnWZ9Sk+4CUTbms4Mb/EU32SZwToAyZ5RgVos/ki8n+yr0LWHOGKuakbXTuuYNHLQjhddgg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0"
+      }
+    },
     "node_modules/append-field": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/append-field/-/append-field-1.0.0.tgz",
@@ -717,6 +1165,12 @@
         "npm": "1.2.8000 || >= 1.4.16"
       }
     },
+    "node_modules/bowser": {
+      "version": "2.14.1",
+      "resolved": "https://registry.npmjs.org/bowser/-/bowser-2.14.1.tgz",
+      "integrity": "sha512-tzPjzCxygAKWFOJP011oxFHs57HzIhOEracIgAePE4pqB3LikALKnSzUyU4MGs9/iCEUuHlAJTjTc5M+u7YEGg==",
+      "license": "MIT"
+    },
     "node_modules/buffer-from": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
@@ -1394,6 +1848,12 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/pako": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz",
+      "integrity": "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==",
+      "license": "(MIT AND Zlib)"
+    },
     "node_modules/parseurl": {
       "version": "1.3.3",
       "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
@@ -1409,6 +1869,24 @@
       "integrity": "sha512-A/AGNMFN3c8bOlvV9RreMdrv7jsmF9XIfDeCd87+I8RNg6s78BhJxMu69NEMHBSJFxKidViTEdruRwEk/WIKqA==",
       "license": "MIT"
     },
+    "node_modules/pdf-lib": {
+      "version": "1.17.1",
+      "resolved": "https://registry.npmjs.org/pdf-lib/-/pdf-lib-1.17.1.tgz",
+      "integrity": "sha512-V/mpyJAoTsN4cnP31vc0wfNA1+p20evqqnap0KLoRUN0Yk/p3wN52DOEsL4oBFcLdb76hlpKPtzJIgo67j/XLw==",
+      "license": "MIT",
+      "dependencies": {
+        "@pdf-lib/standard-fonts": "^1.0.0",
+        "@pdf-lib/upng": "^1.0.1",
+        "pako": "^1.0.11",
+        "tslib": "^1.11.1"
+      }
+    },
+    "node_modules/pdf-lib/node_modules/tslib": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
+      "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
+      "license": "0BSD"
+    },
     "node_modules/playwright": {
       "version": "1.61.1",
       "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.61.1.tgz",

package.json

@@ -10,14 +10,19 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@aws-sdk/client-s3": "^3.1089.0",
+    "@aws-sdk/s3-request-presigner": "^3.1089.0",
     "@supabase/supabase-js": "^2.49.0",
+    "adm-zip": "^0.6.0",
     "dotenv": "^16.4.5",
     "express": "^4.21.0",
     "multer": "^1.4.5-lts.1",
     "node-cron": "^3.0.3",
+    "pdf-lib": "^1.17.1",
     "playwright": "^1.49.0"
   },
   "devDependencies": {
+    "@types/adm-zip": "^0.5.8",
     "@types/express": "^5.0.0",
     "@types/multer": "^1.4.12",
     "@types/node": "^22.0.0",

src/config.ts

@@ -23,10 +23,16 @@ export const config = {
   headless: process.env.PLAYWRIGHT_HEADLESS !== 'false',
 
   // Storage buckets
+  storageProvider: process.env.STORAGE_PROVIDER === 'r2' ? 'r2' : 'supabase',
   inputBucket: process.env.INPUT_BUCKET || 'turnitin-inputs',
   reportBucket: process.env.REPORT_BUCKET || 'turnitin-reports',
   diagnosticsBucket: process.env.DIAGNOSTICS_BUCKET || 'turnitin-diagnostics',
   sessionBucket: process.env.SESSION_BUCKET || 'turnitin-sessions',
+  r2AccountId: process.env.R2_ACCOUNT_ID || '',
+  r2AccessKeyId: process.env.R2_ACCESS_KEY_ID || '',
+  r2SecretAccessKey: process.env.R2_SECRET_ACCESS_KEY || '',
+  r2Endpoint: process.env.R2_ENDPOINT || '',
+  r2Region: process.env.R2_REGION || 'auto',
 
   // Cron intervals (minutes)
   quotaCheckInterval: parseInt(process.env.QUOTA_CHECK_INTERVAL || '30', 10),
@@ -70,6 +76,15 @@ export function validateConfig(): void {
   ];
 
   const missing = required.filter((key) => !config[key]);
+  if (config.storageProvider === 'r2') {
+    const r2Required: (keyof typeof config)[] = [
+      'r2AccountId',
+      'r2AccessKeyId',
+      'r2SecretAccessKey',
+      'r2Endpoint',
+    ];
+    missing.push(...r2Required.filter((key) => !config[key]));
+  }
   if (missing.length > 0) {
     throw new Error(`Missing required environment variables: ${missing.join(', ')}`);
   }

src/db/r2.ts

@@ -0,0 +1,155 @@
+import {
+  DeleteObjectCommand,
+  GetObjectCommand,
+  PutObjectCommand,
+  S3Client,
+} from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import * as fs from 'fs';
+import * as path from 'path';
+import { pipeline } from 'stream/promises';
+import { Readable } from 'stream';
+import { config } from '../config';
+
+const R2_PREFIX = 'r2://';
+let client: S3Client | null = null;
+
+export interface R2ObjectRef {
+  bucket: string;
+  key: string;
+}
+
+function getR2Client(): S3Client {
+  if (!client) {
+    client = new S3Client({
+      region: config.r2Region,
+      endpoint: config.r2Endpoint,
+      forcePathStyle: true,
+      credentials: {
+        accessKeyId: config.r2AccessKeyId,
+        secretAccessKey: config.r2SecretAccessKey,
+      },
+    });
+  }
+  return client;
+}
+
+export function isR2ObjectRef(value: string): boolean {
+  return value.startsWith(R2_PREFIX);
+}
+
+export function createR2ObjectRef(bucket: string, key: string): string {
+  return `${R2_PREFIX}${bucket}/${key.replace(/^\/+/, '')}`;
+}
+
+export function parseR2ObjectRef(value: string): R2ObjectRef {
+  if (!isR2ObjectRef(value)) {
+    throw new Error('Not an R2 object reference');
+  }
+
+  const withoutScheme = value.slice(R2_PREFIX.length);
+  const slashIndex = withoutScheme.indexOf('/');
+  if (slashIndex <= 0 || slashIndex === withoutScheme.length - 1) {
+    throw new Error('Invalid R2 object reference');
+  }
+
+  return {
+    bucket: withoutScheme.slice(0, slashIndex),
+    key: withoutScheme.slice(slashIndex + 1),
+  };
+}
+
+export async function putR2Buffer(
+  bucket: string,
+  key: string,
+  body: Buffer,
+  contentType: string,
+): Promise<string> {
+  await getR2Client().send(
+    new PutObjectCommand({
+      Bucket: bucket,
+      Key: key,
+      Body: body,
+      ContentLength: body.length,
+      ContentType: contentType,
+    }),
+  );
+  return createR2ObjectRef(bucket, key);
+}
+
+export async function putR2File(
+  bucket: string,
+  key: string,
+  localPath: string,
+  contentType: string,
+): Promise<string> {
+  const stat = await fs.promises.stat(localPath);
+  await getR2Client().send(
+    new PutObjectCommand({
+      Bucket: bucket,
+      Key: key,
+      Body: fs.createReadStream(localPath),
+      ContentLength: stat.size,
+      ContentType: contentType,
+    }),
+  );
+  return createR2ObjectRef(bucket, key);
+}
+
+export async function downloadR2File(
+  objectRef: string,
+  localPath: string,
+): Promise<void> {
+  const { bucket, key } = parseR2ObjectRef(objectRef);
+  const response = await getR2Client().send(
+    new GetObjectCommand({ Bucket: bucket, Key: key }),
+  );
+  if (!response.Body) throw new Error(`R2 object body is empty: ${objectRef}`);
+
+  await fs.promises.mkdir(path.dirname(localPath), { recursive: true });
+  await pipeline(response.Body as Readable, fs.createWriteStream(localPath));
+}
+
+export async function readR2Text(objectRef: string): Promise<string | null> {
+  const { bucket, key } = parseR2ObjectRef(objectRef);
+  try {
+    const response = await getR2Client().send(
+      new GetObjectCommand({ Bucket: bucket, Key: key }),
+    );
+    if (!response.Body) return null;
+    return await response.Body.transformToString('utf-8');
+  } catch (error: unknown) {
+    const name = error instanceof Error ? error.name : '';
+    const status = (error as { $metadata?: { httpStatusCode?: number } })?.$metadata
+      ?.httpStatusCode;
+    if (name === 'NoSuchKey' || name === 'NotFound' || status === 404) return null;
+    throw error;
+  }
+}
+
+export async function deleteR2Object(objectRef: string): Promise<void> {
+  const { bucket, key } = parseR2ObjectRef(objectRef);
+  await getR2Client().send(
+    new DeleteObjectCommand({ Bucket: bucket, Key: key }),
+  );
+}
+
+export async function createR2SignedDownloadUrl(
+  objectRef: string,
+  expiresInSeconds: number,
+  downloadFileName?: string,
+): Promise<string> {
+  const { bucket, key } = parseR2ObjectRef(objectRef);
+  const disposition = downloadFileName
+    ? `attachment; filename*=UTF-8''${encodeURIComponent(downloadFileName)}`
+    : undefined;
+  return getSignedUrl(
+    getR2Client(),
+    new GetObjectCommand({
+      Bucket: bucket,
+      Key: key,
+      ResponseContentDisposition: disposition,
+    }),
+    { expiresIn: expiresInSeconds },
+  );
+}

src/db/storage.ts

@@ -3,6 +3,15 @@ import * as path from 'path';
 import { supabase } from './client';
 import { config } from '../config';
 import { logger } from '../utils/logger';
+import {
+  createR2SignedDownloadUrl,
+  deleteR2Object,
+  downloadR2File,
+  isR2ObjectRef,
+  putR2Buffer,
+  putR2File,
+  readR2Text,
+} from './r2';
 
 /**
  * Upload a user's input file to the turnitin-inputs bucket.
@@ -18,6 +27,72 @@ export async function uploadInputFile(
   const ext = path.extname(fileName);
   const storagePath = `${userId}/${storageKey}/input${ext}`;
 
+  if (config.storageProvider === 'r2') {
+    try {
+      return await putR2Buffer(
+        config.inputBucket,
+        storagePath,
+        fileBuffer,
+        getMimeType(ext),
+      );
+    } catch (error) {
+      logger.error('Failed to upload input file to R2', {
+        storagePath,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
+    }
+  }
+
+  const { error } = await supabase.storage
+    .from(config.inputBucket)
+    .upload(storagePath, fileBuffer, {
+      contentType: getMimeType(ext),
+      upsert,
+    });
+
+  if (error) {
+    logger.error('Failed to upload input file', { storagePath, error: error.message });
+    throw error;
+  }
+
+  return storagePath;
+}
+
+/**
+ * Upload an input file from disk. R2 receives a stream so a 100 MB user upload
+ * does not need a second full-size in-memory copy inside the worker.
+ */
+export async function uploadInputFileFromPath(
+  userId: string,
+  storageKey: string,
+  fileName: string,
+  localPath: string,
+  upsert = false,
+): Promise<string> {
+  const ext = path.extname(fileName);
+  const storagePath = `${userId}/${storageKey}/input${ext}`;
+
+  if (config.storageProvider === 'r2') {
+    try {
+      return await putR2File(
+        config.inputBucket,
+        storagePath,
+        localPath,
+        getMimeType(ext),
+      );
+    } catch (error) {
+      logger.error('Failed to upload input file to R2', {
+        storagePath,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
+    }
+  }
+
+  // Supabase Storage's Node client expects a buffer. This fallback only serves
+  // legacy objects/deployments; R2 is the configured destination for new jobs.
+  const fileBuffer = await fs.promises.readFile(localPath);
   const { error } = await supabase.storage
     .from(config.inputBucket)
     .upload(storagePath, fileBuffer, {
@@ -37,6 +112,19 @@ export async function uploadInputFile(
  * Download a file from Supabase Storage to a local path.
  */
 export async function downloadInputFile(storagePath: string, localPath: string): Promise<void> {
+  if (isR2ObjectRef(storagePath)) {
+    try {
+      await downloadR2File(storagePath, localPath);
+      return;
+    } catch (error) {
+      logger.error('Failed to download input file from R2', {
+        storagePath,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
+    }
+  }
+
   const { data, error } = await supabase.storage
     .from(config.inputBucket)
     .download(storagePath);
@@ -54,6 +142,25 @@ export async function downloadInputFile(storagePath: string, localPath: string):
   fs.writeFileSync(localPath, buffer);
 }
 
+/** Delete a staged input when atomic job creation definitively did not happen. */
+export async function deleteInputFile(storagePath: string): Promise<void> {
+  if (isR2ObjectRef(storagePath)) {
+    await deleteR2Object(storagePath);
+    return;
+  }
+
+  const { error } = await supabase.storage
+    .from(config.inputBucket)
+    .remove([storagePath]);
+  if (error) {
+    logger.error('Failed to delete staged input file', {
+      storagePath,
+      error: error.message,
+    });
+    throw error;
+  }
+}
+
 /**
  * Upload a generated report PDF to the turnitin-reports bucket.
  * Returns the storage path and expiry timestamp.
@@ -64,6 +171,28 @@ export async function uploadReportPdf(
   localPdfPath: string,
 ): Promise<{ storagePath: string; expiresAt: string }> {
   const storagePath = `${userId}/${jobId}/report.pdf`;
+
+  if (config.storageProvider === 'r2') {
+    try {
+      const objectRef = await putR2File(
+        config.reportBucket,
+        storagePath,
+        localPdfPath,
+        'application/pdf',
+      );
+      return {
+        storagePath: objectRef,
+        expiresAt: createReportExpiry(),
+      };
+    } catch (error) {
+      logger.error('Failed to upload report PDF to R2', {
+        storagePath,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
+    }
+  }
+
   const fileBuffer = fs.readFileSync(localPdfPath);
 
   const { error } = await supabase.storage
@@ -78,11 +207,7 @@ export async function uploadReportPdf(
     throw error;
   }
 
-  const expiresAt = new Date(
-    Date.now() + config.reportRetentionHours * 60 * 60 * 1000,
-  ).toISOString();
-
-  return { storagePath, expiresAt };
+  return { storagePath, expiresAt: createReportExpiry() };
 }
 
 /**
@@ -95,6 +220,28 @@ export async function uploadReceiptPdf(
   localPdfPath: string,
 ): Promise<{ storagePath: string; expiresAt: string }> {
   const storagePath = `${userId}/${jobId}/receipt.pdf`;
+
+  if (config.storageProvider === 'r2') {
+    try {
+      const objectRef = await putR2File(
+        config.reportBucket,
+        storagePath,
+        localPdfPath,
+        'application/pdf',
+      );
+      return {
+        storagePath: objectRef,
+        expiresAt: createReportExpiry(),
+      };
+    } catch (error) {
+      logger.error('Failed to upload Digital Receipt PDF to R2', {
+        storagePath,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
+    }
+  }
+
   const fileBuffer = fs.readFileSync(localPdfPath);
 
   const { error } = await supabase.storage
@@ -112,17 +259,26 @@ export async function uploadReceiptPdf(
     throw error;
   }
 
-  const expiresAt = new Date(
-    Date.now() + config.reportRetentionHours * 60 * 60 * 1000,
-  ).toISOString();
-
-  return { storagePath, expiresAt };
+  return { storagePath, expiresAt: createReportExpiry() };
 }
 
 /**
  * Delete a report PDF from Supabase Storage.
  */
 export async function deleteReportPdf(storagePath: string): Promise<void> {
+  if (isR2ObjectRef(storagePath)) {
+    try {
+      await deleteR2Object(storagePath);
+      return;
+    } catch (error) {
+      logger.error('Failed to delete report PDF from R2', {
+        storagePath,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
+    }
+  }
+
   const { error } = await supabase.storage
     .from(config.reportBucket)
     .remove([storagePath]);
@@ -143,6 +299,23 @@ export async function uploadStorageState(
 ): Promise<string> {
   const storagePath = `${accountId}/state.json`;
 
+  if (config.storageProvider === 'r2') {
+    try {
+      return await putR2Buffer(
+        config.sessionBucket,
+        storagePath,
+        Buffer.from(stateJson, 'utf-8'),
+        'application/json',
+      );
+    } catch (error) {
+      logger.error('Failed to upload storage state to R2', {
+        accountId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
+    }
+  }
+
   const { error } = await supabase.storage
     .from(config.sessionBucket)
     .upload(storagePath, Buffer.from(stateJson, 'utf-8'), {
@@ -163,6 +336,18 @@ export async function uploadStorageState(
  * Returns the JSON string, or null if not found.
  */
 export async function downloadStorageState(storagePath: string): Promise<string | null> {
+  if (isR2ObjectRef(storagePath)) {
+    try {
+      return await readR2Text(storagePath);
+    } catch (error) {
+      logger.error('Failed to download storage state from R2', {
+        storagePath,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
+    }
+  }
+
   const { data, error } = await supabase.storage
     .from(config.sessionBucket)
     .download(storagePath);
@@ -188,6 +373,23 @@ export async function createSignedUrl(
   expiresInSeconds: number,
   downloadFileName?: string,
 ): Promise<string> {
+  if (isR2ObjectRef(filePath)) {
+    try {
+      return await createR2SignedDownloadUrl(
+        filePath,
+        expiresInSeconds,
+        downloadFileName,
+      );
+    } catch (error) {
+      logger.error('Failed to create R2 signed URL', {
+        bucket,
+        filePath,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
+    }
+  }
+
   const { data, error } = await supabase.storage
     .from(bucket)
     .createSignedUrl(
@@ -204,6 +406,12 @@ export async function createSignedUrl(
   return data.signedUrl;
 }
 
+function createReportExpiry(): string {
+  return new Date(
+    Date.now() + config.reportRetentionHours * 60 * 60 * 1000,
+  ).toISOString();
+}
+
 /** Map file extensions to MIME types */
 function getMimeType(ext: string): string {
   const mimeTypes: Record<string, string> = {

src/engine/legacy.ts

@@ -12,11 +12,22 @@ import type { FilterOptions } from './steps/filters';
 import type { RunTurnitinJobInput, RunTurnitinJobResult } from './turnitin';
 import type { SubmissionDetails } from './steps/submission-details';
 import type { Frame } from 'playwright';
+import { readLocalDocumentMetadata } from '../utils/document-metadata';
 
 type Scope = Page | Frame;
 
 type EngineEvent = NonNullable<RunTurnitinJobInput['onEvent']>;
 const LEGACY_ACCOUNT_QUOTA_LIMIT = 4;
+const LARGE_DOCUMENT_PAGE_THRESHOLD = 100;
+
+function getLegacySimilarityTimeoutMs(pageCount?: number): number {
+  const baseTimeout = Math.max(config.similarityTimeoutMs || 180000, 120000);
+  if (!pageCount || pageCount < LARGE_DOCUMENT_PAGE_THRESHOLD) return baseTimeout;
+
+  const extraHundreds = Math.max(0, Math.floor((pageCount - 100) / 100));
+  const largeDocumentMinutes = Math.min(15, 8 + extraHundreds * 2);
+  return Math.max(baseTimeout, largeDocumentMinutes * 60 * 1000);
+}
 
 async function emit(
   onEvent: RunTurnitinJobInput['onEvent'],
@@ -50,10 +61,16 @@ function parseNumber(value: string | null | undefined): number | undefined {
 }
 
 function parsePercent(value: string | null | undefined): number | null {
-  const match = String(value || '').match(/(\d{1,3})\s*%?/);
-  if (!match) return null;
-  const parsed = Number(match[1]);
-  return Number.isFinite(parsed) ? parsed : null;
+  const text = String(value || '').trim();
+  const explicitPercent = text.match(/(?:^|\D)(\d{1,3})\s*%/);
+  const numericOnly = text.match(/^\d{1,3}$/);
+  const raw = explicitPercent?.[1] || numericOnly?.[0];
+  if (!raw) return null;
+
+  const parsed = Number(raw);
+  return Number.isInteger(parsed) && parsed >= 0 && parsed <= 100
+    ? parsed
+    : null;
 }
 
 function parseFileSizeBytes(value: string | null | undefined): number | undefined {
@@ -68,7 +85,12 @@ function parseFileSizeBytes(value: string | null | undefined): number | undefine
   return Math.round(amount);
 }
 
-function normalizeLabel(label: string): keyof SubmissionDetails | null {
+type ParsedLegacySubmissionDetailKey = Exclude<
+  keyof SubmissionDetails,
+  'pageCountSource' | 'expectedWaitMinutes' | 'largeDocument'
+>;
+
+function normalizeLabel(label: string): ParsedLegacySubmissionDetailKey | null {
   const normalized = label.toLowerCase().replace(/\s+/g, ' ').trim();
   if (normalized === 'student id') return 'studentId';
   if (normalized === 'class name') return 'className';
@@ -581,9 +603,11 @@ async function completeLegacyUpload(
   return reviewDetails;
 }
 
-async function waitForLegacySimilarity(page: Page): Promise<number | null> {
+async function waitForLegacySimilarity(
+  page: Page,
+  timeoutMs: number,
+): Promise<number | null> {
   const startedAt = Date.now();
-  const timeoutMs = Math.max(config.similarityTimeoutMs || 180000, 120000);
   const reloadIntervalMs = 30000; // Reload every 30 seconds
   let lastReloadAt = startedAt;
 
@@ -635,7 +659,11 @@ function isViewerUrl(url: string): boolean {
   return VIEWER_URL_PATTERNS.some((re) => re.test(url));
 }
 
-async function openLegacyViewer(page: Page, context: BrowserContext): Promise<Page> {
+async function openLegacyViewer(
+  page: Page,
+  context: BrowserContext,
+  readyTimeoutMs = 20000,
+): Promise<Page> {
   const opener = page
     .locator('td[data-title="Similarity Score"] a.similarity-open, a.default-open[data-paper-title], a.default-open')
     .first();
@@ -663,11 +691,12 @@ async function openLegacyViewer(page: Page, context: BrowserContext): Promise<Pa
     throw new Error(`Legacy report viewer did not open. Current URL: ${viewerPage.url()}`);
   }
 
-  // Wait for the carta viewer sidebar to render filter controls (up to 20 s).
+  // Large documents may finish the dashboard score before the Carta sidebar
+  // has fully hydrated, so the caller can grant a longer readiness window.
   await visible(
     viewerPage,
     '.apply-changes-button, .osi-score, .sidebar-paper-info-button, .exclude-quotes-checkbox',
-    20000,
+    readyTimeoutMs,
   ).catch(() => {});
 
   return viewerPage;
@@ -1700,6 +1729,52 @@ export async function runLegacyTurnitinJob(
 
   const result: RunTurnitinJobResult = {};
   let page: Page | null = null;
+  const localDocumentMetadata =
+    requestedMode === 'quota_check'
+      ? {}
+      : await readLocalDocumentMetadata(inputFilePath);
+  const localPageCount = localDocumentMetadata.pageCount;
+  const largeDocument = Boolean(
+    localPageCount && localPageCount >= LARGE_DOCUMENT_PAGE_THRESHOLD,
+  );
+  const similarityTimeoutMs = getLegacySimilarityTimeoutMs(localPageCount);
+  const expectedWaitMinutes = Math.ceil(similarityTimeoutMs / 60000);
+
+  if (localPageCount) {
+    result.submissionDetails = {
+      pageCount: localPageCount,
+      pageCountSource: localDocumentMetadata.pageCountSource,
+      expectedWaitMinutes,
+      largeDocument,
+    };
+    await emit(
+      onEvent,
+      'info',
+      'submission_details',
+      `Document page count detected: ${localPageCount} pages.`,
+      {
+        pageCount: localPageCount,
+        pageCountSource: localDocumentMetadata.pageCountSource,
+        expectedWaitMinutes,
+        largeDocument,
+      },
+    );
+    if (largeDocument) {
+      await emit(
+        onEvent,
+        'warning',
+        'large_document',
+        `Large document detected: ${localPageCount} pages. Similarity processing may take up to ${expectedWaitMinutes} minutes.`,
+        {
+          pageCount: localPageCount,
+          pageCountSource: localDocumentMetadata.pageCountSource,
+          expectedWaitMinutes,
+          largeDocument: true,
+        },
+      );
+    }
+  }
+
   const browser = await getBrowser();
   const contextOptions: Record<string, unknown> = {
     userAgent:
@@ -1775,8 +1850,17 @@ export async function runLegacyTurnitinJob(
         });
         const reviewDetails = await completeLegacyUpload(scope, inputFilePath, inputFileName || path.basename(inputFilePath));
         if (reviewDetails) {
-          result.submissionDetails = reviewDetails;
-          await emit(onEvent, 'info', 'submission_details', 'Legacy review details captured', reviewDetails as Record<string, unknown>);
+          result.submissionDetails = {
+            ...(result.submissionDetails || {}),
+            ...reviewDetails,
+          };
+          await emit(
+            onEvent,
+            'info',
+            'submission_details',
+            'Legacy review details captured',
+            result.submissionDetails as Record<string, unknown>,
+          );
         }
         result.submittedAt = new Date().toISOString();
         result.lastCompletedStep = 'submitted';
@@ -1786,15 +1870,27 @@ export async function runLegacyTurnitinJob(
       }
 
       await emit(onEvent, 'info', 'similarity', 'Waiting for legacy similarity score');
-      const tableSimilarity = await waitForLegacySimilarity(page);
+      const tableSimilarity = await waitForLegacySimilarity(page, similarityTimeoutMs);
       if (tableSimilarity !== null) result.similarityPercent = tableSimilarity;
       result.lastCompletedStep = 'similarity';
       await emit(onEvent, 'info', 'similarity', `Similarity: ${result.similarityPercent ?? 'pending'}%`, {
         similarityPercent: result.similarityPercent,
+        pageCount: localPageCount,
+        timeoutMs: similarityTimeoutMs,
       });
 
+      if (tableSimilarity === null) {
+        throw new Error(
+          `Legacy similarity is still processing after ${expectedWaitMinutes} minutes. Retrying from the similarity checkpoint without uploading the file again.`,
+        );
+      }
+
       await emit(onEvent, 'info', 'viewer', 'Opening legacy report viewer');
-      page = await openLegacyViewer(page, context);
+      page = await openLegacyViewer(
+        page,
+        context,
+        largeDocument ? 60000 : 20000,
+      );
       result.viewerUrl = page.url();
       result.lastCompletedStep = 'viewer';
       await emit(onEvent, 'info', 'viewer', 'Legacy report viewer opened', {

src/engine/steps/submission-details.ts

@@ -17,9 +17,17 @@ export interface SubmissionDetails {
   charCount?: number;
   wordCount?: number;
   pageCount?: number;
+  pageCountSource?: 'pdf' | 'docx_metadata';
+  expectedWaitMinutes?: number;
+  largeDocument?: boolean;
 }
 
-function normalizeKey(label: string): keyof SubmissionDetails | null {
+type ParsedSubmissionDetailKey = Exclude<
+  keyof SubmissionDetails,
+  'pageCountSource' | 'expectedWaitMinutes' | 'largeDocument'
+>;
+
+function normalizeKey(label: string): ParsedSubmissionDetailKey | null {
   const normalized = label.toLowerCase().replace(/\s+/g, ' ').trim();
   if (normalized === 'student id') return 'studentId';
   if (normalized === 'class name') return 'className';

src/server/routes/submit.ts

@@ -1,7 +1,7 @@
-import { Router, Response } from 'express';
+import { NextFunction, Request, Router, Response } from 'express';
 import multer from 'multer';
 import { authenticateUser, AuthenticatedRequest } from '../middleware/auth';
-import { uploadInputFile } from '../../db/storage';
+import { deleteInputFile, uploadInputFileFromPath } from '../../db/storage';
 import {
   createJobWithTicket,
   getJobBySubmissionRequestId,
@@ -9,15 +9,43 @@ import {
 } from '../../db/tickets';
 import { logger } from '../../utils/logger';
 import { createHash, randomUUID } from 'crypto';
+import { createReadStream, promises as fsPromises } from 'fs';
+import * as os from 'os';
 
 const router = Router();
 
-/** Multer configured for in-memory storage (files go to Supabase, not local disk) */
+/**
+ * Keep large uploads out of the worker heap. The route removes every temporary
+ * file after validation/storage, including early returns and failed requests.
+ */
 const upload = multer({
-  storage: multer.memoryStorage(),
-  limits: { fileSize: 50 * 1024 * 1024 }, // 50 MB
+  storage: multer.diskStorage({
+    destination: os.tmpdir(),
+    filename: (_req, file, callback) => {
+      callback(null, `relv-upload-${randomUUID()}${getFileExtension(file.originalname)}`);
+    },
+  }),
+  limits: { fileSize: 100 * 1024 * 1024 }, // User uploads are capped at 100 MB
 });
 
+function receiveUpload(
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): void {
+  upload.single('file')(req, res, (error: unknown) => {
+    if (error instanceof multer.MulterError && error.code === 'LIMIT_FILE_SIZE') {
+      res.status(413).json({ error: 'File exceeds the 100MB upload limit' });
+      return;
+    }
+    if (error) {
+      next(error);
+      return;
+    }
+    next();
+  });
+}
+
 /** Allowed file extensions for Turnitin submissions */
 const ALLOWED_EXTENSIONS = new Set([
   '.docx',
@@ -48,6 +76,14 @@ function getFileExtension(filename: string): string {
   return lastDot >= 0 ? filename.slice(lastDot).toLowerCase() : '';
 }
 
+async function sha256File(filePath: string): Promise<string> {
+  const hash = createHash('sha256');
+  for await (const chunk of createReadStream(filePath)) {
+    hash.update(chunk as Buffer);
+  }
+  return hash.digest('hex');
+}
+
 function existingJobMatchesRequest(
   existingJob: {
     assignment_target_id: string;
@@ -81,9 +117,10 @@ function existingJobMatchesRequest(
 router.post(
   '/api/submit',
   authenticateUser,
-  upload.single('file'),
+  receiveUpload,
   async (req, res: Response): Promise<void> => {
     const authReq = req as AuthenticatedRequest;
+    const temporaryUploadPath = authReq.file?.path;
 
     try {
       // 1. Validate required fields
@@ -138,9 +175,10 @@ router.post(
         res.status(400).json({ error: 'File is required' });
         return;
       }
+      const uploadedFile = authReq.file;
 
       // 3. Validate file type
-      const ext = getFileExtension(authReq.file.originalname);
+      const ext = getFileExtension(uploadedFile.originalname);
       if (!ALLOWED_EXTENSIONS.has(ext)) {
         res.status(400).json({
           error: `Unsupported file type: ${ext}. Allowed: ${[...ALLOWED_EXTENSIONS].join(', ')}`,
@@ -170,9 +208,7 @@ router.post(
       }
 
       // 5. Fingerprint the payload before any state-changing operation.
-      const inputFileSha256 = createHash('sha256')
-        .update(authReq.file.buffer)
-        .digest('hex');
+      const inputFileSha256 = await sha256File(uploadedFile.path);
 
       const existingJob = await getJobBySubmissionRequestId(
         authReq.userId,
@@ -183,8 +219,8 @@ router.post(
         if (!existingJobMatchesRequest(existingJob, {
           assignmentTargetId: String(assignment_target_id),
           mode: String(mode),
-          inputFileName: authReq.file.originalname,
-          inputFileSize: authReq.file.size,
+          inputFileName: uploadedFile.originalname,
+          inputFileSize: uploadedFile.size,
           inputFileSha256,
         })) {
           res.status(409).json({
@@ -209,27 +245,81 @@ router.post(
 
       // A deterministic request/hash path makes concurrent retries upload the
       // same bytes to the same object before the database invariant resolves them.
-      const storagePath = await uploadInputFile(
+      const storagePath = await uploadInputFileFromPath(
         authReq.userId,
         `${submissionRequestId}/${inputFileSha256}`,
-        authReq.file.originalname,
-        authReq.file.buffer,
+        uploadedFile.originalname,
+        uploadedFile.path,
         true,
       );
 
       // 6. Atomically create one job/ticket ledger entry, or return the job
       // already created by another Space handling this exact request.
-      const creation = await createJobWithTicket({
-        userId: authReq.userId,
-        assignmentTargetId: assignment_target_id,
-        mode,
-        filters,
-        inputFileName: authReq.file.originalname,
-        inputStoragePath: storagePath,
-        inputFileSize: authReq.file.size,
-        inputFileSha256,
-        submissionRequestId,
-      });
+      const creation = await (async () => {
+        try {
+          return await createJobWithTicket({
+            userId: authReq.userId,
+            assignmentTargetId: assignment_target_id,
+            mode,
+            filters,
+            inputFileName: uploadedFile.originalname,
+            inputStoragePath: storagePath,
+            inputFileSize: uploadedFile.size,
+            inputFileSha256,
+            submissionRequestId,
+          });
+        } catch (creationError) {
+          // The RPC response may fail after the transaction commits. Confirm
+          // database state before deleting the staged object.
+          let recoveredJob;
+          try {
+            recoveredJob = await getJobBySubmissionRequestId(
+              authReq.userId,
+              submissionRequestId,
+            );
+          } catch (recoveryError) {
+            logger.warn('Could not verify job creation after RPC failure; preserving input object', {
+              userId: authReq.userId,
+              submissionRequestId,
+              error:
+                recoveryError instanceof Error
+                  ? recoveryError.message
+                  : String(recoveryError),
+            });
+            throw creationError;
+          }
+
+          if (recoveredJob) {
+            if (!existingJobMatchesRequest(recoveredJob, {
+              assignmentTargetId: String(assignment_target_id),
+              mode: String(mode),
+              inputFileName: uploadedFile.originalname,
+              inputFileSize: uploadedFile.size,
+              inputFileSha256,
+            })) {
+              await deleteInputFile(storagePath).catch(() => {});
+              throw new Error('Idempotency key recovered a different job payload');
+            }
+            logger.warn('Recovered committed job after job-creation response failure', {
+              jobId: recoveredJob.id,
+              userId: authReq.userId,
+              submissionRequestId,
+            });
+            return { jobId: recoveredJob.id, created: false };
+          }
+
+          await deleteInputFile(storagePath).catch((cleanupError: unknown) => {
+            logger.warn('Failed to roll back staged input after job creation failure', {
+              storagePath,
+              error:
+                cleanupError instanceof Error
+                  ? cleanupError.message
+                  : String(cleanupError),
+            });
+          });
+          throw creationError;
+        }
+      })();
 
       // Fetch updated ticket balance
       const profile = await getUserProfile(authReq.userId);
@@ -238,7 +328,7 @@ router.post(
       logger.info(creation.created ? 'Job submitted successfully' : 'Idempotent submit race resolved', {
         jobId: creation.jobId,
         userId: authReq.userId,
-        fileName: authReq.file.originalname,
+        fileName: uploadedFile.originalname,
         submissionRequestId,
       });
 
@@ -268,6 +358,15 @@ router.post(
       });
 
       res.status(500).json({ error: 'Internal server error' });
+    } finally {
+      if (temporaryUploadPath) {
+        await fsPromises.unlink(temporaryUploadPath).catch((error: unknown) => {
+          logger.warn('Failed to remove temporary upload file', {
+            temporaryUploadPath,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        });
+      }
     }
   },
 );

src/utils/document-metadata.ts

@@ -0,0 +1,48 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import AdmZip from 'adm-zip';
+import { PDFDocument } from 'pdf-lib';
+import { logger } from './logger';
+
+export interface LocalDocumentMetadata {
+  pageCount?: number;
+  pageCountSource?: 'pdf' | 'docx_metadata';
+}
+
+export async function readLocalDocumentMetadata(
+  filePath: string,
+): Promise<LocalDocumentMetadata> {
+  if (!filePath || !fs.existsSync(filePath)) return {};
+
+  const extension = path.extname(filePath).toLowerCase();
+  try {
+    if (extension === '.pdf') {
+      const bytes = await fs.promises.readFile(filePath);
+      const pdf = await PDFDocument.load(bytes, {
+        ignoreEncryption: true,
+        updateMetadata: false,
+      });
+      const pageCount = pdf.getPageCount();
+      return pageCount > 0 ? { pageCount, pageCountSource: 'pdf' } : {};
+    }
+
+    if (extension === '.docx') {
+      const archive = new AdmZip(filePath);
+      const appProperties = archive.getEntry('docProps/app.xml');
+      if (!appProperties) return {};
+      const xml = appProperties.getData().toString('utf-8');
+      const match = xml.match(/<(?:\w+:)?Pages>\s*(\d+)\s*<\/(?:\w+:)?Pages>/i);
+      const pageCount = match ? Number(match[1]) : 0;
+      return pageCount > 0
+        ? { pageCount, pageCountSource: 'docx_metadata' }
+        : {};
+    }
+  } catch (error) {
+    logger.warn('Could not read local document page count', {
+      filePath: path.basename(filePath),
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+
+  return {};
+}