screenci 0.0.75 → 0.0.78

package/dist/cli.js

@@ -10,10 +10,13 @@ import { Command, CommanderError } from 'commander';
 import pc from 'picocolors';
 import { logger } from './src/logger.js';
 import { determinePackageManager, parsePackageManager, runInit, } from './src/init.js';
-import { SCREENCI_DISABLE_RECORDING_TIMINGS_ENV, SCREENCI_MOCK_RECORD_ENV, SCREENCI_LANGUAGES_ENV, SCREENCI_TEXT_OVERRIDES_ENV, SCREENCI_RECORD_OPTIONS_ENV, } from './src/runtimeMode.js';
+import { SCREENCI_DISABLE_RECORDING_TIMINGS_ENV, SCREENCI_MOCK_RECORD_ENV, SCREENCI_LANGUAGES_ENV, SCREENCI_VALUES_OVERRIDES_ENV, SCREENCI_RECORD_OPTIONS_ENV, isUploadExistingEnabled, } from './src/runtimeMode.js';
 import { DEFAULT_RECORD_UPLOAD_POLICY } from './src/defaults.js';
 import { findDuplicateTitles, formatDuplicateTitlesMessage, } from './src/titleValidation.js';
 import { createLinkSessionSpec, deletePersistedLinkSessionSpec, getCliLinkSessionApiUrl, getDevBackendUrl, getDevFrontendUrl, getLinkSessionFilePath, getScreenCIEnvironment, isStoredLinkSessionReusable, readPersistedLinkSessionSpec, SCREENCI_LINK_SESSION_FILE, writePersistedLinkSessionSpec, } from './src/linkSession.js';
+import { OVERLAY_CACHE_DIR_NAME } from './src/htmlRasterizer.js';
+import { openUrlInBrowser } from './src/openBrowser.js';
+import { maybeExtractVoiceSampleAudio } from './src/voiceSampleAudio.js';
 // Re-export the environment-aware URL helpers so existing importers (and tests)
 // can keep importing them from the CLI entrypoint.
 export { getCliLinkSessionApiUrl, getDevBackendUrl, getDevFrontendUrl };
@@ -214,10 +217,22 @@ function contentTypeForPath(filePath) {
         mp4: 'video/mp4',
         webm: 'video/webm',
         mp3: 'audio/mpeg',
+        wav: 'audio/wav',
+        m4a: 'audio/mp4',
+        aac: 'audio/aac',
         svg: 'image/svg+xml',
     };
     return contentTypeMap[ext] ?? 'application/octet-stream';
 }
+/** Human label per upload kind, shown as `<label> uploaded: <path>`. */
+const UPLOAD_ASSET_LABEL = {
+    overlay: 'Overlay',
+    audio: 'Audio',
+    // A `videoCueStart` asset: a media file placed on the narration timeline
+    // (e.g. via `narration({ en: { intro: { media } } })`).
+    clip: 'Narration',
+    voice: 'Voice',
+};
 export function formatStudioUrl(appUrl, projectId, videoId) {
     // The video hub resolves `?studio` to the right language page and scrolls it
     // to Studio, so we never need to guess the language in the printed link.
@@ -345,15 +360,19 @@ async function loadUploadCandidate(screenciDir, entry, verbose) {
     }
     const videoName = data.metadata?.videoName ?? entry;
     const preparedUploadAssets = await collectUploadAssets(data, resolve(screenciDir, '..'));
+    // The recording data is annotated with asset hashes later, in
+    // uploadRecordingCandidate, after any locally missing assets have been
+    // resolved against a previous upload. Annotating here would strip the asset
+    // paths the resolve step needs to match on.
     return {
         entry,
         videoName,
-        data: annotateRecordingDataWithAssetHashes(data, preparedUploadAssets),
+        data,
         preparedUploadAssets,
     };
 }
-async function uploadRecordingCandidate(candidate, screenciDir, projectName, apiUrl, secret, elevenLabsApiKey, verbose, uploadAbort, progressReporter, progressIndex, recordId) {
-    const { entry, videoName, data, preparedUploadAssets } = candidate;
+async function uploadRecordingCandidate(candidate, screenciDir, projectName, apiUrl, secret, verbose, uploadAbort, progressReporter, progressIndex, recordId, expectedScreenshotCount) {
+    const { entry, videoName, data: rawData, preparedUploadAssets } = candidate;
     let projectId = null;
     let videoId = null;
     let plan = null;
@@ -362,9 +381,9 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
         // A screenshot recording uploads its raw page capture (always a PNG) through
         // the same recording endpoint a video uses; the renderer reads those bytes as
         // the capture. Videos upload recording.mp4. Output kind defaults to 'video'.
-        const isScreenshot = data.output === 'screenshot';
+        const isScreenshot = rawData.output === 'screenshot';
         const recordingFileName = isScreenshot
-            ? (data.screenshot?.path ?? 'screenshot.png')
+            ? (rawData.screenshot?.path ?? 'screenshot.png')
             : 'recording.mp4';
         const recordingContentType = isScreenshot ? 'image/png' : 'video/mp4';
         const recordingPath = resolve(screenciDir, entry, recordingFileName);
@@ -379,15 +398,29 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
                 recordId,
             };
         }
+        // Locally missing assets (e.g. gitignored media on CI) carry no bytes and,
+        // for overlays, no hash. Recover their identity from a previous upload of
+        // this video before starting, so the recording data references them by hash
+        // and the backend existence check confirms they are still stored.
+        const unresolved = await resolveMissingUploadAssets(preparedUploadAssets, projectName, videoName, apiUrl, secret, uploadAbort.signal, progressReporter);
+        if (unresolved.length > 0) {
+            progressReporter.complete(progressIndex, 'failure');
+            return {
+                projectId: null,
+                videoId: null,
+                hadFailure: true,
+                videoName,
+                failureMessage: formatUnresolvedAssetMessage(videoName, unresolved),
+                recordId,
+            };
+        }
+        const data = annotateRecordingDataWithAssetHashes(rawData, preparedUploadAssets);
         const recordingHash = await hashFile(recordingPath);
         const startResponse = await withUploadRetry(() => fetch(`${apiUrl}/cli/upload/start`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
                 'X-ScreenCI-Secret': secret,
-                ...(elevenLabsApiKey
-                    ? { 'X-ElevenLabs-Api-Key': elevenLabsApiKey }
-                    : {}),
             },
             body: JSON.stringify({
                 projectName,
@@ -395,6 +428,7 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
                 data,
                 recordingHash,
                 recordId,
+                ...(isScreenshot ? { expectedScreenshotCount } : {}),
                 expectedAssets: preparedUploadAssets.map((asset) => ({
                     fileHash: asset.fileHash,
                     size: asset.size,
@@ -425,6 +459,16 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
         videoId = startBody.videoId ?? null;
         plan = startBody.plan ?? null;
         const studio = startBody.studio;
+        // Render-dependency validation failures are reported on the upload response
+        // so the author sees them at record time. These are enforced server-side:
+        // the render for this video fails with the dependency error until fixed.
+        if (startBody.dependencyErrors && startBody.dependencyErrors.length > 0) {
+            for (const depError of startBody.dependencyErrors) {
+                logger.error(`Render dependency error in "${videoName}": ${depError.detail}. This render will fail until it is fixed.`);
+            }
+        }
+        // The missing-ElevenLabs-key warning is surfaced once in the final summary
+        // (see uploadRecordings), where it is not overwritten by the upload spinner.
         if (verbose) {
             logger.info(`recordingId=${recordingId} projectId=${projectId}`);
             logger.info(`assets=${preparedUploadAssets.length} recordingHash=${recordingHash ?? 'none'}`);
@@ -448,9 +492,6 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
                         'Content-Type': recordingContentType,
                         'Content-Length': String(fileStat.size),
                         'X-ScreenCI-Secret': secret,
-                        ...(elevenLabsApiKey
-                            ? { 'X-ElevenLabs-Api-Key': elevenLabsApiKey }
-                            : {}),
                     },
                     body: stream,
                     signal: uploadAbort.signal,
@@ -470,7 +511,7 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
                 videoId,
                 hadFailure: true,
                 videoName,
-                failureMessage: `Failed to upload recording for "${videoName}": ${recordingResponse.status} ${text}${hint401(recordingResponse.status, secret)}`,
+                failureMessage: `Failed to upload recording for "${videoName}": ${recordingResponse.status} ${extractBackendError(text)}${hint401(recordingResponse.status, secret)}`,
                 recordId,
                 ...(plan !== null && { plan }),
             };
@@ -485,6 +526,13 @@ async function uploadRecordingCandidate(candidate, screenciDir, projectName, api
             recordId,
             ...(studio !== undefined && { studio }),
             ...(plan !== null && { plan }),
+            ...(startBody.elevenLabsKeyMissing === true && {
+                elevenLabsKeyMissing: true,
+            }),
+            ...(Array.isArray(startBody.notices) &&
+                startBody.notices.length > 0 && {
+                notices: startBody.notices.filter((notice) => typeof notice === 'string'),
+            }),
         };
     }
     catch (err) {
@@ -708,11 +756,17 @@ function forwardChildSignals(child, activityLabel, options = {}) {
         getForwardedSignal: () => forwardedSignal,
     };
 }
-function clearRecordingDirectories(dir) {
+export function clearRecordingDirectories(dir) {
     mkdirSync(dir, { recursive: true });
     for (const entry of readdirSync(dir)) {
         if (entry === SCREENCI_LINK_SESSION_FILE)
             continue;
+        // Preserve the cross-run overlay cache: it lives as a sibling of the
+        // per-recording directories so unchanged overlays are served byte for byte
+        // from a previous run. Wiping it would re-render and re-encode every overlay
+        // each run, changing their content hashes and forcing a re-upload.
+        if (entry === OVERLAY_CACHE_DIR_NAME)
+            continue;
         rmSync(resolve(dir, entry), { recursive: true, force: true });
     }
 }
@@ -821,32 +875,56 @@ async function prepareCustomVoiceAssets(data, configDir) {
         const resolvedFile = await readRecordingFile(voicePath, configDir, sourceFilePath);
         if (resolvedFile === null) {
             const existingHash = refs.find((ref) => typeof ref.assetHash === 'string')?.assetHash;
-            if (!existingHash) {
-                throw new Error(`Custom voice file not found and no cached assetHash available: ${voicePath}`);
-            }
-            logger.warn(`Custom voice file not found locally, assuming previously uploaded recording asset is valid: ${voicePath}`);
-            for (const ref of refs) {
-                ref.assetHash = existingHash;
+            if (existingHash) {
+                // The recording already carries this voice's content hash, so reference
+                // it by that hash. The backend check confirms it is still stored.
+                for (const ref of refs) {
+                    ref.assetHash = existingHash;
+                }
+                preparedAssets.push({
+                    kind: 'voice',
+                    fileHash: existingHash,
+                    path: voicePath,
+                    size: 0,
+                    contentType: contentTypeForPath(voicePath),
+                    assumedUploaded: true,
+                });
+                continue;
             }
+            // No cached hash either. Recover the voice's identity from a previous
+            // upload of this video, matched by path. resolveMissingUploadAssets fills
+            // in the hash and writes it back onto the cue refs.
             preparedAssets.push({
-                fileHash: existingHash,
+                kind: 'voice',
+                fileHash: '',
                 path: voicePath,
                 size: 0,
                 contentType: contentTypeForPath(voicePath),
+                needsResolve: true,
             });
             continue;
         }
         const { buffer: fileBuffer, resolvedPath } = resolvedFile;
-        const assetHash = createHash('sha256').update(fileBuffer).digest('hex');
-        const contentType = contentTypeForPath(resolvedPath);
+        // Identify the voice by the ORIGINAL file, so the clone cache survives any
+        // re-encode of the uploaded bytes (see backend resolveCustomVoice).
+        const sampleHash = createHash('sha256').update(fileBuffer).digest('hex');
+        // A voice clone only needs audio, and the clone service caps samples at
+        // ~11 MB. For video containers (or any oversized file) strip to a small MP3
+        // before upload; otherwise upload the audio unchanged.
+        const extracted = await maybeExtractVoiceSampleAudio(resolvedPath, fileBuffer.byteLength);
+        const uploadBuffer = extracted?.buffer ?? fileBuffer;
+        const contentType = extracted?.contentType ?? contentTypeForPath(resolvedPath);
+        const assetHash = createHash('sha256').update(uploadBuffer).digest('hex');
         for (const ref of refs) {
             ref.assetHash = assetHash;
+            ref.sampleHash = sampleHash;
         }
         preparedAssets.push({
+            kind: 'voice',
             fileHash: assetHash,
             path: voicePath,
-            size: fileBuffer.byteLength,
-            fileBuffer,
+            size: uploadBuffer.byteLength,
+            fileBuffer: uploadBuffer,
             contentType,
         });
     }
@@ -861,15 +939,29 @@ export async function collectUploadAssets(data, configDir) {
             // page and merged into the recording by the backend.
             if ('studio' in event && event.studio === true)
                 continue;
+            // Render dependencies (selected(...)) have no local file: the backend
+            // resolves the target render's output and injects it at dispatch time.
+            if ('dependency' in event)
+                continue;
             if (assets.has(`name:${event.name}`))
                 continue;
             const resolvedFile = await readRecordingFile(event.path, configDir, sourceFilePath);
             if (resolvedFile === null) {
-                logger.warn(`Asset file not found, skipping upload: ${event.path}`);
+                // The local file is gone (e.g. gitignored media on CI). Reference it so
+                // its identity can be recovered from a previous upload of this video.
+                assets.set(`name:${event.name}`, {
+                    kind: 'overlay',
+                    fileHash: '',
+                    path: event.path,
+                    name: event.name,
+                    size: 0,
+                    needsResolve: true,
+                });
                 continue;
             }
             const { buffer: fileBuffer, resolvedPath } = resolvedFile;
             assets.set(`name:${event.name}`, {
+                kind: 'overlay',
                 fileHash: createHash('sha256').update(fileBuffer).digest('hex'),
                 path: event.path,
                 name: event.name,
@@ -879,6 +971,57 @@ export async function collectUploadAssets(data, configDir) {
             });
             continue;
         }
+        if (event.type === 'audioStart') {
+            // Studio audio tracks have no local file.
+            if ('studio' in event && event.studio === true)
+                continue;
+            // Prefer the record-time content hash as the dedup key; a missing local
+            // file may have been emitted without one, so fall back to the path.
+            const dedupKey = event.fileHash
+                ? `hash:${event.fileHash}`
+                : `path:${event.path}`;
+            if (assets.has(dedupKey))
+                continue;
+            const resolvedFile = await readRecordingFile(event.path, configDir, sourceFilePath);
+            if (resolvedFile === null) {
+                // The local file is gone. If the recording still carries its content
+                // hash, reference it by that hash (the backend check confirms it is
+                // stored). Otherwise recover its identity from a previous upload by path.
+                // Captured screen audio (`__screen`) is per-recording and can never be
+                // recovered from a prior upload, so it is simply skipped when missing.
+                if (event.fileHash) {
+                    assets.set(dedupKey, {
+                        kind: 'audio',
+                        fileHash: event.fileHash,
+                        path: event.path,
+                        size: 0,
+                        assumedUploaded: true,
+                        ...(event.name === '__screen' && { alwaysUpload: true }),
+                    });
+                }
+                else if (event.name !== '__screen') {
+                    assets.set(dedupKey, {
+                        kind: 'audio',
+                        fileHash: '',
+                        path: event.path,
+                        size: 0,
+                        needsResolve: true,
+                    });
+                }
+                continue;
+            }
+            assets.set(dedupKey, {
+                kind: 'audio',
+                fileHash: event.fileHash ??
+                    createHash('sha256').update(resolvedFile.buffer).digest('hex'),
+                path: event.path,
+                size: resolvedFile.buffer.byteLength,
+                fileBuffer: resolvedFile.buffer,
+                contentType: contentTypeForPath(resolvedFile.resolvedPath),
+                ...(event.name === '__screen' && { alwaysUpload: true }),
+            });
+            continue;
+        }
         if (event.type === 'videoCueStart') {
             // Single-language: hash already computed during recording, use assetPath to read file
             if (typeof event.assetHash === 'string' &&
@@ -887,38 +1030,79 @@ export async function collectUploadAssets(data, configDir) {
                     ? await readRecordingFile(event.assetPath, configDir, sourceFilePath)
                     : null;
                 assets.set(`hash:${event.assetHash}`, {
+                    kind: 'clip',
                     fileHash: event.assetHash,
                     path: event.assetPath ?? event.assetHash,
                     size: resolvedFile?.buffer.byteLength ?? 0,
-                    ...(resolvedFile !== null && {
-                        fileBuffer: resolvedFile.buffer,
-                        contentType: contentTypeForPath(resolvedFile.resolvedPath),
-                    }),
+                    ...(resolvedFile !== null
+                        ? {
+                            fileBuffer: resolvedFile.buffer,
+                            contentType: contentTypeForPath(resolvedFile.resolvedPath),
+                        }
+                        : { assumedUploaded: true }),
                 });
             }
+            else if (typeof event.assetHash !== 'string' &&
+                typeof event.assetPath === 'string' &&
+                !assets.has(`path:${event.assetPath}`)) {
+                // The media file was gone at record time, so it carries no hash. Recover
+                // its identity from a previous upload of this video, matched by path.
+                const resolvedFile = await readRecordingFile(event.assetPath, configDir, sourceFilePath);
+                if (resolvedFile === null) {
+                    assets.set(`path:${event.assetPath}`, {
+                        kind: 'clip',
+                        fileHash: '',
+                        path: event.assetPath,
+                        size: 0,
+                        needsResolve: true,
+                    });
+                }
+            }
             // Multi-language: each translation carries its own hash
             if (event.translations) {
                 for (const translation of Object.values(event.translations)) {
-                    if (typeof translation === 'object' &&
-                        translation !== null &&
-                        'assetHash' in translation &&
-                        typeof translation.assetHash === 'string' &&
-                        !assets.has(`hash:${translation.assetHash}`)) {
-                        const resolvedFile = 'assetPath' in translation &&
-                            typeof translation.assetPath === 'string'
-                            ? await readRecordingFile(translation.assetPath, configDir, sourceFilePath)
+                    if (typeof translation !== 'object' || translation === null)
+                        continue;
+                    const assetHash = 'assetHash' in translation &&
+                        typeof translation.assetHash === 'string'
+                        ? translation.assetHash
+                        : undefined;
+                    const assetPath = 'assetPath' in translation &&
+                        typeof translation.assetPath === 'string'
+                        ? translation.assetPath
+                        : undefined;
+                    if (assetHash !== undefined) {
+                        if (assets.has(`hash:${assetHash}`))
+                            continue;
+                        const resolvedFile = assetPath !== undefined
+                            ? await readRecordingFile(assetPath, configDir, sourceFilePath)
                             : null;
-                        assets.set(`hash:${translation.assetHash}`, {
-                            fileHash: translation.assetHash,
-                            path: translation.assetPath ??
-                                translation.assetHash,
+                        assets.set(`hash:${assetHash}`, {
+                            kind: 'clip',
+                            fileHash: assetHash,
+                            path: assetPath ?? assetHash,
                             size: resolvedFile?.buffer.byteLength ?? 0,
-                            ...(resolvedFile !== null && {
-                                fileBuffer: resolvedFile.buffer,
-                                contentType: contentTypeForPath(resolvedFile.resolvedPath),
-                            }),
+                            ...(resolvedFile !== null
+                                ? {
+                                    fileBuffer: resolvedFile.buffer,
+                                    contentType: contentTypeForPath(resolvedFile.resolvedPath),
+                                }
+                                : { assumedUploaded: true }),
                         });
                     }
+                    else if (assetPath !== undefined &&
+                        !assets.has(`path:${assetPath}`)) {
+                        const resolvedFile = await readRecordingFile(assetPath, configDir, sourceFilePath);
+                        if (resolvedFile === null) {
+                            assets.set(`path:${assetPath}`, {
+                                kind: 'clip',
+                                fileHash: '',
+                                path: assetPath,
+                                size: 0,
+                                needsResolve: true,
+                            });
+                        }
+                    }
                 }
             }
         }
@@ -928,23 +1112,47 @@ export async function collectUploadAssets(data, configDir) {
     }
     return [...assets.values()];
 }
-export function stripVoicePath(voice) {
+export function stripVoicePath(voice, byPath) {
     if (typeof voice !== 'string') {
-        return { assetHash: voice.assetHash };
+        // A voice recovered from a previous upload has no record-time assetHash; fill
+        // it in from the resolved-by-path map before the path is dropped.
+        const assetHash = voice.assetHash ??
+            (byPath !== undefined && typeof voice.assetPath === 'string'
+                ? byPath.get(voice.assetPath)
+                : undefined);
+        return { assetHash: assetHash };
     }
     return voice;
 }
 export function annotateRecordingDataWithAssetHashes(data, assets) {
+    // Overlays are matched to their hash by name; every other asset kind (audio,
+    // narration clip, custom voice) is matched by its file path. Skip placeholder
+    // hashes that were never resolved so a missing entry stays untouched.
     const byName = new Map();
+    const byPath = new Map();
     for (const asset of assets) {
+        if (asset.fileHash.length === 0)
+            continue;
         if (typeof asset.name === 'string')
             byName.set(asset.name, asset.fileHash);
+        byPath.set(asset.path, asset.fileHash);
     }
     return {
         ...data,
         events: data.events.map((event) => {
             if (event.type === 'assetStart') {
-                const fileHash = byName.get(event.name);
+                if ('studio' in event || 'dependency' in event)
+                    return event;
+                const fileHash = byName.get(event.name) ?? event.fileHash;
+                return fileHash ? { ...event, fileHash } : event;
+            }
+            if (event.type === 'audioStart') {
+                // Studio audio tracks carry no local path; leave them untouched.
+                if (!('path' in event))
+                    return event;
+                if (event.fileHash)
+                    return event;
+                const fileHash = byPath.get(event.path);
                 return fileHash ? { ...event, fileHash } : event;
             }
             if (event.type === 'cueStart' && event.translations) {
@@ -956,7 +1164,7 @@ export function annotateRecordingDataWithAssetHashes(data, assets) {
                         language,
                         {
                             ...translation,
-                            voice: stripVoicePath(translation.voice),
+                            voice: stripVoicePath(translation.voice, byPath),
                         },
                     ];
                 }));
@@ -964,12 +1172,21 @@ export function annotateRecordingDataWithAssetHashes(data, assets) {
             }
             if (event.type !== 'videoCueStart')
                 return event;
-            // Strip assetPath from translations — hash was already computed during recording
+            // Strip assetPath from translations. The hash was either computed during
+            // recording or recovered from a previous upload (matched by that path).
             if (event.translations) {
                 const translations = Object.fromEntries(Object.entries(event.translations).map(([language, translation]) => {
-                    if ('assetHash' in translation) {
-                        const { assetPath: _removed, ...rest } = translation;
-                        return [language, rest];
+                    if ('assetHash' in translation || 'assetPath' in translation) {
+                        const file = translation;
+                        const assetHash = file.assetHash ??
+                            (file.assetPath !== undefined
+                                ? byPath.get(file.assetPath)
+                                : undefined);
+                        const { assetPath: _removed, ...rest } = file;
+                        return [
+                            language,
+                            assetHash !== undefined ? { ...rest, assetHash } : rest,
+                        ];
                     }
                     if ('voice' in translation) {
                         return [
@@ -977,7 +1194,7 @@ export function annotateRecordingDataWithAssetHashes(data, assets) {
                             {
                                 ...translation,
                                 ...(translation.voice !== undefined
-                                    ? { voice: stripVoicePath(translation.voice) }
+                                    ? { voice: stripVoicePath(translation.voice, byPath) }
                                     : {}),
                             },
                         ];
@@ -986,10 +1203,15 @@ export function annotateRecordingDataWithAssetHashes(data, assets) {
                 }));
                 return { ...event, translations };
             }
-            // Single-language: strip assetPath, keep assetHash
-            if (typeof event.assetHash === 'string') {
+            // Single-language: keep the assetHash (recovering it by path if needed) and
+            // drop the now-redundant assetPath.
+            const assetHash = event.assetHash ??
+                (typeof event.assetPath === 'string'
+                    ? byPath.get(event.assetPath)
+                    : undefined);
+            if (typeof assetHash === 'string') {
                 const { assetPath: _removed, ...rest } = event;
-                return rest;
+                return { ...rest, assetHash };
             }
             return event;
         }),
@@ -999,7 +1221,27 @@ function hint401(status, secret) {
     if (status !== 401 || !secret)
         return '';
     const frontendUrl = getDevFrontendUrl();
-    return `\nThe secret may have been deleted or belongs to a different organisation. Check your secrets at ${frontendUrl}/secrets`;
+    return `\nThe secret may have been deleted. Check your secrets at ${frontendUrl}/secrets`;
+}
+/**
+ * Reduces a backend error response to its human-readable message. Backend
+ * failures reply with a JSON body like `{"error":"..."}`; this returns just the
+ * `error` string so failures print the message, not the raw JSON. Non-JSON or
+ * shapeless bodies fall back to the original text unchanged.
+ */
+export function extractBackendError(responseText) {
+    if (responseText.trim().length === 0)
+        return responseText;
+    try {
+        const parsed = JSON.parse(responseText);
+        if (typeof parsed.error === 'string' && parsed.error.trim().length > 0) {
+            return parsed.error;
+        }
+    }
+    catch {
+        // Not JSON: fall back to the raw response text.
+    }
+    return responseText;
 }
 export function formatUploadStartFailureMessage(videoName, status, responseText, secret) {
     if (responseText.trim().length > 0) {
@@ -1041,6 +1283,80 @@ export function displayAssetPath(assetPath) {
     const rel = pathRelative(process.cwd(), assetPath);
     return rel.length > 0 ? rel : assetPath;
 }
+/**
+ * Recovers the identity of assets whose local file was absent during collection
+ * (no bytes, and for overlays no hash) by matching them, by path or name,
+ * against a previous upload of the same video. Each resolved asset is mutated in
+ * place: its `fileHash`, `size`, and `contentType` are filled in and it is
+ * flagged `assumedUploaded` so the later existence check confirms the bytes are
+ * still stored rather than trying to upload absent bytes.
+ *
+ * Returns the assets that could not be resolved (no previous version), so the
+ * caller can fail the recording with actionable guidance.
+ */
+export async function resolveMissingUploadAssets(assets, projectName, videoName, apiUrl, secret, signal, progressReporter) {
+    const pending = assets.filter((asset) => asset.needsResolve === true);
+    if (pending.length === 0)
+        return [];
+    const refs = pending.map((asset) => ({
+        path: asset.path,
+        ...(typeof asset.name === 'string' ? { name: asset.name } : {}),
+        kind: asset.kind,
+    }));
+    const res = await withUploadRetry(() => fetch(`${apiUrl}/cli/upload/resolve-assets`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'X-ScreenCI-Secret': secret,
+        },
+        body: JSON.stringify({ projectName, videoName, assets: refs }),
+        signal,
+    }), signal);
+    if (!res.ok) {
+        const text = await res.text();
+        throw new UploadAssetError(`Failed to resolve previously uploaded assets for "${videoName}": ${res.status} ${extractBackendError(text)}${hint401(res.status, secret)}`);
+    }
+    const body = (await res.json());
+    const resolved = Array.isArray(body.resolved) ? body.resolved : [];
+    const logInfo = (message) => {
+        if (progressReporter)
+            progressReporter.info(message);
+        else
+            logger.info(message);
+    };
+    const unresolved = [];
+    pending.forEach((asset, index) => {
+        const match = resolved[index];
+        if (match && typeof match.fileHash === 'string') {
+            asset.fileHash = match.fileHash;
+            asset.size = match.size ?? 0;
+            if (typeof match.contentType === 'string') {
+                asset.contentType = match.contentType;
+            }
+            asset.needsResolve = false;
+            asset.assumedUploaded = true;
+            logInfo(`${pc.green('✔')} Locally missing ${UPLOAD_ASSET_LABEL[asset.kind].toLowerCase()}, reusing the previously uploaded version: ${displayAssetPath(asset.path)}`);
+        }
+        else {
+            unresolved.push(asset);
+        }
+    });
+    return unresolved;
+}
+/**
+ * Builds the failure message shown when locally missing assets have no
+ * previously uploaded version to reuse.
+ */
+export function formatUnresolvedAssetMessage(videoName, unresolved) {
+    const list = unresolved
+        .map((asset) => `  - ${UPLOAD_ASSET_LABEL[asset.kind]}: ${asset.path}`)
+        .join('\n');
+    return [
+        `Some asset files are missing locally and no previously uploaded version was found for "${videoName}":`,
+        list,
+        'Record once with these files present so they are uploaded, or commit them so they are available here.',
+    ].join('\n');
+}
 async function uploadAssets(assets, apiUrl, secret, recordingId, signal, throwIfAborted, progressReporter) {
     const logInfo = (message) => {
         if (progressReporter) {
@@ -1052,63 +1368,75 @@ async function uploadAssets(assets, apiUrl, secret, recordingId, signal, throwIf
     };
     for (const asset of assets) {
         throwIfAborted();
+        const label = UPLOAD_ASSET_LABEL[asset.kind];
         try {
-            const checkRes = await withUploadRetry(() => fetch(`${apiUrl}/cli/upload/${recordingId}/asset/check`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'X-ScreenCI-Secret': secret,
-                },
-                body: JSON.stringify({
-                    fileHash: asset.fileHash,
-                    contentType: asset.contentType,
-                    size: asset.size,
-                    path: asset.path,
-                    ...(typeof asset.name === 'string' ? { name: asset.name } : {}),
-                }),
-                signal,
-            }), signal);
-            if (!checkRes.ok) {
-                const text = await checkRes.text();
-                throw new UploadAssetError(`Failed to check asset ${asset.path}: ${checkRes.status} ${text}${hint401(checkRes.status, secret)}`);
-            }
-            const checkBody = (await checkRes.json());
-            if (checkBody.exists) {
-                logInfo(`${pc.green('✔')} Asset already exists: ${displayAssetPath(asset.path)}`);
-                continue;
+            if (!asset.alwaysUpload) {
+                const checkRes = await withUploadRetry(() => fetch(`${apiUrl}/cli/upload/${recordingId}/asset/check`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-ScreenCI-Secret': secret,
+                    },
+                    body: JSON.stringify({
+                        fileHash: asset.fileHash,
+                        contentType: asset.contentType,
+                        size: asset.size,
+                        path: asset.path,
+                        ...(typeof asset.name === 'string' ? { name: asset.name } : {}),
+                    }),
+                    signal,
+                }), signal);
+                if (!checkRes.ok) {
+                    const text = await checkRes.text();
+                    throw new UploadAssetError(`Failed to check asset ${displayAssetPath(asset.path)}: ${checkRes.status} ${extractBackendError(text)}${hint401(checkRes.status, secret)}`);
+                }
+                const checkBody = (await checkRes.json());
+                if (checkBody.exists) {
+                    logInfo(asset.assumedUploaded
+                        ? `${pc.green('✔')} Locally missing ${label.toLowerCase()}, already uploaded: ${displayAssetPath(asset.path)}`
+                        : `${pc.green('✔')} ${label} already exists: ${displayAssetPath(asset.path)}`);
+                    continue;
+                }
             }
             if (!asset.fileBuffer || !asset.contentType) {
-                throw new UploadAssetError(`Asset bytes not available for upload and backend does not have it yet: ${asset.path}`);
+                // A locally missing asset matched a previous upload by path/name, but its
+                // bytes are not in this environment's storage. There is nothing to push.
+                if (asset.assumedUploaded) {
+                    throw new UploadAssetError(`${label} is missing locally and its previously uploaded bytes are no longer stored: ${displayAssetPath(asset.path)}. Record once with the file present so it is uploaded again, or commit the file.`);
+                }
+                throw new UploadAssetError(`Asset bytes not available for upload and backend does not have it yet: ${displayAssetPath(asset.path)}`);
             }
             const fileBuffer = asset.fileBuffer;
+            const contentType = asset.contentType;
             throwIfAborted();
-            const res = await withUploadRetry(() => fetch(`${apiUrl}/cli/upload/${recordingId}/asset`, {
+            const res = await withUploadRetry(() => 
+            // Send the raw bytes, not base64-in-JSON: base64 builds a string that
+            // exceeds Node's max string length (~536MB) for large assets. Metadata
+            // travels in headers (URI-encoded so non-ASCII paths stay header-safe).
+            fetch(`${apiUrl}/cli/upload/${recordingId}/asset/stream`, {
                 method: 'PUT',
                 headers: {
-                    'Content-Type': 'application/json',
+                    'Content-Type': contentType,
+                    'Content-Length': String(fileBuffer.byteLength),
                     'X-ScreenCI-Secret': secret,
+                    'X-ScreenCI-File-Hash': asset.fileHash,
+                    'X-ScreenCI-Asset-Size': String(asset.size),
+                    'X-ScreenCI-Asset-Path': encodeURIComponent(asset.path),
                 },
-                body: JSON.stringify({
-                    fileHash: asset.fileHash,
-                    fileBase64: fileBuffer.toString('base64'),
-                    contentType: asset.contentType,
-                    size: asset.size,
-                    path: asset.path,
-                    ...(typeof asset.name === 'string' ? { name: asset.name } : {}),
-                }),
+                body: fileBuffer,
                 signal,
             }), signal);
             if (!res.ok) {
                 const text = await res.text();
                 if (res.status === 409 && text.includes('already exists')) {
-                    logInfo(`${pc.green('✔')} Asset already exists: ${displayAssetPath(asset.path)}`);
+                    logInfo(`${pc.green('✔')} ${label} already exists: ${displayAssetPath(asset.path)}`);
                 }
                 else {
-                    throw new UploadAssetError(`Failed to upload asset ${asset.path}: ${res.status} ${text}${hint401(res.status, secret)}`);
+                    throw new UploadAssetError(`Failed to upload asset ${displayAssetPath(asset.path)}: ${res.status} ${extractBackendError(text)}${hint401(res.status, secret)}`);
                 }
             }
             else {
-                logInfo(`Asset uploaded: ${displayAssetPath(asset.path)}`);
+                logInfo(`${pc.green('✔')} ${label} uploaded: ${displayAssetPath(asset.path)}`);
             }
         }
         catch (err) {
@@ -1118,7 +1446,7 @@ async function uploadAssets(assets, apiUrl, secret, recordingId, signal, throwIf
             if (isUploadAssetError(err)) {
                 throw err;
             }
-            throw new UploadAssetError(`Network error uploading asset ${asset.path}: ${err instanceof Error ? err.message : String(err)}`);
+            throw new UploadAssetError(`Network error uploading asset ${displayAssetPath(asset.path)}: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
 }
@@ -1138,6 +1466,8 @@ export async function uploadRecordings(screenciDir, projectName, apiUrl, secret,
             failedVideoNames: [],
             failedVideoMessages: [],
             studioNotices: [],
+            elevenLabsKeyMissingVideos: [],
+            notices: [],
             plan: null,
         };
     }
@@ -1145,7 +1475,6 @@ export async function uploadRecordings(screenciDir, projectName, apiUrl, secret,
         entries = entries.filter((e) => e === specificEntry);
     }
     let firstProjectId = null;
-    const elevenLabsApiKey = process.env.ELEVENLABS_API_KEY?.trim() || undefined;
     try {
         const candidates = (await Promise.all(entries.map(async (entry) => {
             uploadAbort.throwIfAborted();
@@ -1159,11 +1488,17 @@ export async function uploadRecordings(screenciDir, projectName, apiUrl, secret,
                 failedVideoNames: [],
                 failedVideoMessages: [],
                 studioNotices: [],
+                elevenLabsKeyMissingVideos: [],
+                notices: [],
                 plan: null,
             };
         }
         const progressReporter = createUploadProgressReporter(candidates.map((candidate) => candidate.videoName), verbose);
-        const results = await Promise.all(candidates.map(async (candidate, index) => await uploadRecordingCandidate(candidate, screenciDir, projectName, apiUrl, secret, elevenLabsApiKey, verbose, uploadAbort, progressReporter, index, recordId)));
+        // Screenshots from this run render together on one machine; the backend
+        // waits for all of them to land before dispatching the batch, so it needs
+        // to know how many to expect.
+        const screenshotCount = candidates.filter((candidate) => candidate.data.output === 'screenshot').length;
+        const results = await Promise.all(candidates.map(async (candidate, index) => await uploadRecordingCandidate(candidate, screenciDir, projectName, apiUrl, secret, verbose, uploadAbort, progressReporter, index, recordId, screenshotCount)));
         firstProjectId =
             results.find((result) => result.projectId !== null)?.projectId ?? null;
         const resolvedPlan = results.find((result) => result.plan !== undefined)?.plan ?? null;
@@ -1183,6 +1518,10 @@ export async function uploadRecordings(screenciDir, projectName, apiUrl, secret,
                 },
             ]
             : []);
+        const elevenLabsKeyMissingVideos = results.flatMap((result) => !result.hadFailure && result.elevenLabsKeyMissing === true
+            ? [result.videoName]
+            : []);
+        const notices = results.flatMap((result) => !result.hadFailure && result.notices !== undefined ? result.notices : []);
         return {
             projectId: firstProjectId,
             recordId,
@@ -1190,6 +1529,8 @@ export async function uploadRecordings(screenciDir, projectName, apiUrl, secret,
             failedVideoNames,
             failedVideoMessages,
             studioNotices,
+            elevenLabsKeyMissingVideos,
+            notices,
             plan: resolvedPlan,
         };
     }
@@ -1310,19 +1651,29 @@ function isMissingFileError(err) {
 }
 async function loadEnvFileFromConfigSource(resolvedConfigPath, warnOnFailure) {
     try {
-        const screenciConfig = await tryReadConfigFromSource(resolvedConfigPath);
-        loadEnvFile(screenciConfig.envFile
-            ? resolve(dirname(resolvedConfigPath), screenciConfig.envFile)
-            : resolve(dirname(resolvedConfigPath), '.env'), warnOnFailure);
+        const envFilePath = (await resolveConfiguredEnvFilePath(resolvedConfigPath)) ??
+            resolve(dirname(resolvedConfigPath), '.env');
+        loadEnvFile(envFilePath, warnOnFailure);
     }
     catch {
         // Config import may require Playwright context or dynamic values. Continue with
         // the existing process env; Playwright will still load the config normally.
     }
 }
-async function resolveConfiguredEnvFilePath(resolvedConfigPath) {
+// Resolve `envFile` the way Playwright resolves a config value: by evaluating
+// the config module, not by scraping its source text. A dynamic
+// `envFile: isLocal ? '.env.local' : '.env'` only has a real value once the
+// module runs, so evaluating it lets local and prod setups pick the right file
+// (scraping the source can only see a plain string literal, and silently falls
+// back to `.env`). The environment the expression depends on (e.g.
+// SCREENCI_ENVIRONMENT, set by the `screenci:*:local` scripts) is already in
+// place before this runs, so the CLI resolves the same file Playwright will
+// when it later evaluates the same config. `loadRecordConfigWithoutPlaywright
+// Collision` only falls back to static source parsing if the module cannot be
+// imported.
+export async function resolveConfiguredEnvFilePath(resolvedConfigPath) {
     try {
-        const screenciConfig = await tryReadConfigFromSource(resolvedConfigPath);
+        const screenciConfig = await loadRecordConfigWithoutPlaywrightCollision(resolvedConfigPath);
         if (!screenciConfig.envFile)
             return undefined;
         return resolve(dirname(resolvedConfigPath), screenciConfig.envFile);
@@ -1459,7 +1810,7 @@ async function updateVideoVisibility(videoId, isPublic, configPath) {
     });
     if (!res.ok) {
         const text = await res.text();
-        throw new Error(`Failed to ${isPublic ? 'make public' : 'make private'}: ${res.status} ${text}${hint401(res.status, secret)}`);
+        throw new Error(`Failed to ${isPublic ? 'make public' : 'make private'}: ${res.status} ${extractBackendError(text)}${hint401(res.status, secret)}`);
     }
     logger.info(`${isPublic ? 'Made public' : 'Made private'}: ${videoId}`);
 }
@@ -1501,7 +1852,7 @@ async function triggerRemoteRun(configPath, grep, languages) {
     });
     if (!res.ok) {
         const text = await res.text();
-        throw new Error(`Failed to trigger remote run: ${res.status} ${text}${hint401(res.status, secret)}`);
+        throw new Error(`Failed to trigger remote run: ${res.status} ${extractBackendError(text)}${hint401(res.status, secret)}`);
     }
     const filters = [
         ...(grep ? [`filter: ${grep}`] : []),
@@ -1562,7 +1913,7 @@ async function printInfo(configPath) {
     });
     if (!res.ok) {
         const text = await res.text();
-        throw new Error(`Failed to fetch info: ${res.status} ${text}${hint401(res.status, secret)}`);
+        throw new Error(`Failed to fetch info: ${res.status} ${extractBackendError(text)}${hint401(res.status, secret)}`);
     }
     const data = await res.json();
     process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
@@ -1757,10 +2108,220 @@ export async function ensureScreenciSecret(resolvedConfigPath, opts = {}) {
         return undefined;
     }
 }
+/**
+ * `screenci login`: get a sign-in link in front of a human as early as
+ * possible. It reuses the link `init` (or a prior run) persisted, or creates a
+ * fresh one, tries to open it in the browser best-effort, and always prints it
+ * as a fallback. It does NOT wait for sign-in to finish: the agent can run this,
+ * keep authoring and `test`ing, then `record` (which blocks for sign-in) once
+ * the script is green. If sign-in already completed, it saves the secret and
+ * exits.
+ */
+export async function runLogin(configPath) {
+    const { resolvedConfigPath } = await loadScreenCIConfigAndEnv(configPath);
+    if (process.env.SCREENCI_SECRET) {
+        logger.info(`Already signed in (SCREENCI_SECRET is set). Run ${pc.cyan(getSuggestedScreenciCommand('record'))} to record.`);
+        return;
+    }
+    const environment = getScreenCIEnvironment();
+    const apiUrl = getCliLinkSessionApiUrl();
+    const appUrl = getDevFrontendUrl();
+    const envFilePath = await resolveProjectEnvFilePath(resolvedConfigPath);
+    const projectDir = dirname(resolvedConfigPath);
+    const specPath = getLinkSessionFilePath(projectDir);
+    const linkSessionContext = { environment, envFilePath, resolvedConfigPath };
+    const createSpec = async () => {
+        const created = await createLinkSessionSpec({
+            apiUrl,
+            appUrl,
+            ...linkSessionContext,
+        });
+        await writePersistedLinkSessionSpec(specPath, created);
+        return created;
+    };
+    try {
+        // Reuse a still-valid persisted session so login and a later record share
+        // the same link; otherwise create and persist a fresh one.
+        const stored = await readPersistedLinkSessionSpec(specPath);
+        let spec = stored && isStoredLinkSessionReusable(stored, linkSessionContext)
+            ? stored
+            : await createSpec();
+        // If sign-in already completed (e.g. between runs) save the secret and stop:
+        // there is nothing left to open. Recreate a stale session before opening so
+        // the link we hand off is valid.
+        const result = await pollLinkSessionOnce(spec);
+        if (result.status === 'completed' && result.secret) {
+            process.env.SCREENCI_SECRET = result.secret;
+            await persistScreenCISecret(envFilePath, result.secret);
+            deletePersistedLinkSessionSpec(specPath);
+            logger.info(`Already signed in. Saved SCREENCI_SECRET to ${envFilePath}.`);
+            return;
+        }
+        if (result.status === 'expired' ||
+            result.status === 'consumed' ||
+            result.status === 'invalid') {
+            deletePersistedLinkSessionSpec(specPath);
+            spec = await createSpec();
+        }
+        const opened = await openUrlInBrowser(spec.appUrl);
+        if (opened.opened) {
+            logger.info(`Opening the sign-in link in your browser:\n${pc.cyan(spec.appUrl)}`);
+        }
+        else {
+            logger.info(`Could not open a browser automatically (${opened.reason}). Open this link to sign in:\n${pc.cyan(spec.appUrl)}`);
+        }
+        logger.info(`The link stays valid for 24 hours. You can keep authoring and run ${pc.cyan(getSuggestedScreenciCommand('test'))} while you sign in. Then run ${pc.cyan(getSuggestedScreenciCommand('record'))}, which waits for sign-in and records once you finish.`);
+    }
+    catch (err) {
+        // Login is a best-effort convenience: never fail the run on a network or
+        // browser hiccup. record can still create and wait on the link later.
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.warn(`Could not start sign-in: ${msg}`);
+        logger.info(`You can sign in later: ${pc.cyan(getSuggestedScreenciCommand('record'))} prints a link and waits for sign-in. In CI, set SCREENCI_SECRET (from ${getScreenCISecretsUrl()}).`);
+    }
+}
+// Uploads the recordings already written under `.screenci` for the resolved
+// config. Shared by `record` (after a Playwright run) and `retry` (which
+// re-sends the existing recordings without re-running Playwright). A non-null
+// `playwrightFailure` means the preceding record run had failures, which tunes
+// the messaging and the upload policy; `retry` always passes null.
+async function uploadRecordedVideosForConfig(configPath, playwrightFailure, verbose) {
+    // After recording, upload results to API if configured. `run` already
+    // resolved the config (or exited), so this best-effort lookup only acts
+    // when a flat config is present in/under the current directory.
+    const resolution = findScreenCIConfig(configPath);
+    if (resolution.kind !== 'found')
+        return;
+    const resolvedConfigPath = resolution.path;
+    try {
+        const screenciConfig = await loadRecordConfigWithoutPlaywrightCollision(resolvedConfigPath);
+        loadEnvFile(screenciConfig.envFile
+            ? resolve(dirname(resolvedConfigPath), screenciConfig.envFile)
+            : resolve(dirname(resolvedConfigPath), '.env'), true);
+        const apiUrl = getDevBackendUrl();
+        const appUrl = getDevFrontendUrl();
+        const secret = process.env.SCREENCI_SECRET;
+        const uploadPolicy = resolveRecordUploadPolicy(screenciConfig);
+        const configDir = dirname(resolvedConfigPath);
+        const screenciDir = resolve(configDir, '.screenci');
+        const completedRecordingCount = await countCompletedRecordings(screenciDir);
+        if (playwrightFailure !== null && completedRecordingCount === 0) {
+            logger.info('All recordings failed.');
+        }
+        else if (!secret) {
+            logger.info(`No SCREENCI_SECRET configured for uploads. Rerun ${getSuggestedScreenciCommand('record')} or add it to the project env file.`);
+        }
+        else if (playwrightFailure !== null &&
+            uploadPolicy === 'all-or-nothing') {
+            logger.info('Some recordings failed, skipping upload because record.upload is "all-or-nothing".');
+        }
+        else {
+            if (playwrightFailure !== null && uploadPolicy === 'passed-only') {
+                logger.warn('Some recordings failed, uploading successful videos only.');
+            }
+            let uploadResult = {
+                projectId: null,
+                recordId: null,
+                hadFailures: false,
+                failedVideoNames: [],
+                failedVideoMessages: [],
+                studioNotices: [],
+                elevenLabsKeyMissingVideos: [],
+                notices: [],
+                plan: null,
+            };
+            try {
+                uploadResult = await uploadRecordings(screenciDir, screenciConfig.projectName, apiUrl, secret, undefined, verbose);
+            }
+            catch (err) {
+                if (isUploadCancelledError(err)) {
+                    process.exit(130);
+                }
+                throw err;
+            }
+            const { projectId, recordId, hadFailures, failedVideoNames, failedVideoMessages, studioNotices, elevenLabsKeyMissingVideos, notices, plan, } = uploadResult;
+            // Remember this run so `screenci info` can report exactly it.
+            if (recordId !== null) {
+                await saveLastRecordId(screenciDir, recordId);
+            }
+            // Emit upload-failure warnings (stderr) before the results block.
+            // logger.info writes to stdout, logger.warn to stderr; in non-TTY CI
+            // logs stdout is block-buffered while stderr flushes immediately, so
+            // warnings printed after the "Results available at:" line would split
+            // it from its URL. Reporting failures first keeps the URL directly
+            // under its message.
+            if (hadFailures) {
+                for (const failedVideo of failedVideoMessages) {
+                    logger.warn(formatFailedVideoMessage(failedVideo.videoName, failedVideo.message));
+                }
+                logger.warn(`Not all recordings succeeded to upload. Failed videos: ${failedVideoNames.join(', ') || 'unknown'}. Some videos may be missing from the project.`);
+            }
+            if (recordId !== null && projectId !== null) {
+                const recordUrl = `${appUrl}/record/${recordId}`;
+                await writeGitHubProjectOutput(recordUrl);
+                logger.info('');
+                logger.info(playwrightFailure !== null
+                    ? 'Recording partially succeeded, rendering in progress. Results available at:'
+                    : 'Recording finished, rendering in progress. Results available at:');
+                logger.info(pc.cyan(recordUrl));
+            }
+            else if (projectId !== null) {
+                const projectUrl = `${appUrl}/project/${projectId}`;
+                await writeGitHubProjectOutput(projectUrl);
+                logger.info('');
+                logger.info(playwrightFailure !== null
+                    ? 'Recording partially succeeded, rendering in progress. Results available at:'
+                    : 'Recording finished, rendering in progress. Results available at:');
+                logger.info(pc.cyan(projectUrl));
+            }
+            if (notices.length > 0) {
+                logger.info('');
+                for (const notice of notices) {
+                    logger.notice(notice);
+                }
+            }
+            if (projectId !== null && plan !== 'business') {
+                logger.info('');
+                logger.info('Upgrade for more renders, more active videos, and expressive narration:');
+                logger.info(pc.cyan(`${appUrl}/select-plan`));
+            }
+            for (const notice of studioNotices) {
+                if ('held' in notice.studio) {
+                    logger.info('');
+                    logger.info(`Rendering for "${notice.videoName}" is on hold. Configure it in Studio:`);
+                    if (projectId !== null && notice.videoId !== null) {
+                        logger.info(pc.cyan(formatStudioUrl(appUrl, projectId, notice.videoId)));
+                    }
+                }
+                else if (notice.studio.applied) {
+                    logger.info('');
+                    logger.info(`Studio configuration applied for "${notice.videoName}".`);
+                }
+            }
+            if (elevenLabsKeyMissingVideos.length > 0) {
+                const names = elevenLabsKeyMissingVideos
+                    .map((name) => `"${name}"`)
+                    .join(', ');
+                logger.info('');
+                logger.error(`${names} ${elevenLabsKeyMissingVideos.length === 1 ? 'uses' : 'use'} an ElevenLabs or custom voice, but your organization has no ElevenLabs API key, so ${elevenLabsKeyMissingVideos.length === 1 ? 'its render' : 'those renders'} will fail. Add your key on the Secrets page:`);
+                logger.info(pc.cyan(getScreenCISecretsUrl()));
+            }
+            if (hadFailures && playwrightFailure === null) {
+                throw new PartialUploadError();
+            }
+        }
+    }
+    catch (err) {
+        if (isPartialUploadError(err)) {
+            throw err;
+        }
+        logger.warn('Failed to load config for upload:', err);
+    }
+}
 export async function main() {
     if (process.argv.length <= 2) {
         logger.error('Error: No command provided');
-        logger.error('Available commands: record, test, info, make-public, make-private, init');
+        logger.error('Available commands: record, test, login, info, make-public, make-private, init');
         process.exit(1);
     }
     const program = new Command();
@@ -1788,130 +2349,32 @@ export async function main() {
             return;
         }
         let playwrightFailure = null;
-        try {
-            await run('record', parsed.otherArgs, parsed.configPath, parsed.verbose, false, parsed.pollAuth, parsed.languages, parsed.noPollAuth);
-        }
-        catch (error) {
-            if (!(error instanceof Error))
-                throw error;
-            if (error.message.startsWith('Playwright exited with code ')) {
-                playwrightFailure = new RecordFailureHintError(error);
-            }
-            else {
-                throw new RecordFailureHintError(error);
-            }
-        }
-        if (process.env.SCREENCI_RECORDING === 'true')
-            return;
-        // After recording, upload results to API if configured. `run` already
-        // resolved the config (or exited), so this best-effort lookup only acts
-        // when a flat config is present in/under the current directory.
-        const resolution = findScreenCIConfig(parsed.configPath);
-        if (resolution.kind === 'found') {
-            const resolvedConfigPath = resolution.path;
+        // UPLOAD_EXISTING re-sends the recordings already on disk under `.screenci`
+        // without re-running Playwright (resend the last local run when only the
+        // upload failed). We skip the recording run and fall straight through to
+        // the upload below, treating the on-disk recordings as the complete set.
+        const uploadExisting = isUploadExistingEnabled();
+        if (!uploadExisting) {
             try {
-                const screenciConfig = await loadRecordConfigWithoutPlaywrightCollision(resolvedConfigPath);
-                loadEnvFile(screenciConfig.envFile
-                    ? resolve(dirname(resolvedConfigPath), screenciConfig.envFile)
-                    : resolve(dirname(resolvedConfigPath), '.env'), true);
-                const apiUrl = getDevBackendUrl();
-                const appUrl = getDevFrontendUrl();
-                const secret = process.env.SCREENCI_SECRET;
-                const uploadPolicy = resolveRecordUploadPolicy(screenciConfig);
-                const configDir = dirname(resolvedConfigPath);
-                const screenciDir = resolve(configDir, '.screenci');
-                const completedRecordingCount = await countCompletedRecordings(screenciDir);
-                if (playwrightFailure !== null && completedRecordingCount === 0) {
-                    logger.info('All recordings failed.');
-                }
-                else if (!secret) {
-                    logger.info(`No SCREENCI_SECRET configured for uploads. Rerun ${getSuggestedScreenciCommand('record')} or add it to the project env file.`);
-                }
-                else if (playwrightFailure !== null &&
-                    uploadPolicy === 'all-or-nothing') {
-                    logger.info('Some recordings failed, skipping upload because record.upload is "all-or-nothing".');
+                await run('record', parsed.otherArgs, parsed.configPath, parsed.verbose, false, parsed.pollAuth, parsed.languages, parsed.noPollAuth);
+            }
+            catch (error) {
+                if (!(error instanceof Error))
+                    throw error;
+                if (error.message.startsWith('Playwright exited with code ')) {
+                    playwrightFailure = new RecordFailureHintError(error);
                 }
                 else {
-                    if (playwrightFailure !== null && uploadPolicy === 'passed-only') {
-                        logger.warn('Some recordings failed, uploading successful videos only.');
-                    }
-                    let uploadResult = {
-                        projectId: null,
-                        recordId: null,
-                        hadFailures: false,
-                        failedVideoNames: [],
-                        failedVideoMessages: [],
-                        studioNotices: [],
-                        plan: null,
-                    };
-                    try {
-                        uploadResult = await uploadRecordings(screenciDir, screenciConfig.projectName, apiUrl, secret);
-                    }
-                    catch (err) {
-                        if (isUploadCancelledError(err)) {
-                            process.exit(130);
-                        }
-                        throw err;
-                    }
-                    const { projectId, recordId, hadFailures, failedVideoNames, failedVideoMessages, studioNotices, plan, } = uploadResult;
-                    // Remember this run so `screenci info` can report exactly it.
-                    if (recordId !== null) {
-                        await saveLastRecordId(screenciDir, recordId);
-                    }
-                    if (recordId !== null && projectId !== null) {
-                        const recordUrl = `${appUrl}/record/${recordId}`;
-                        await writeGitHubProjectOutput(recordUrl);
-                        logger.info('');
-                        logger.info(playwrightFailure !== null
-                            ? 'Recording partially succeeded, rendering in progress. Results available at:'
-                            : 'Recording finished, rendering in progress. Results available at:');
-                        logger.info(pc.cyan(recordUrl));
-                    }
-                    else if (projectId !== null) {
-                        const projectUrl = `${appUrl}/project/${projectId}`;
-                        await writeGitHubProjectOutput(projectUrl);
-                        logger.info('');
-                        logger.info(playwrightFailure !== null
-                            ? 'Recording partially succeeded, rendering in progress. Results available at:'
-                            : 'Recording finished, rendering in progress. Results available at:');
-                        logger.info(pc.cyan(projectUrl));
-                    }
-                    if (projectId !== null && plan !== 'business') {
-                        logger.info('');
-                        logger.info('Upgrade for more renders, more active videos, and expressive narration:');
-                        logger.info(pc.cyan(`${appUrl}/select-plan`));
-                    }
-                    for (const notice of studioNotices) {
-                        if ('held' in notice.studio) {
-                            logger.info('');
-                            logger.info(`Rendering for "${notice.videoName}" is on hold — configure it in Studio:`);
-                            if (projectId !== null && notice.videoId !== null) {
-                                logger.info(pc.cyan(formatStudioUrl(appUrl, projectId, notice.videoId)));
-                            }
-                        }
-                        else if (notice.studio.applied) {
-                            logger.info('');
-                            logger.info(`Studio configuration applied for "${notice.videoName}".`);
-                        }
-                    }
-                    if (hadFailures) {
-                        for (const failedVideo of failedVideoMessages) {
-                            logger.warn(formatFailedVideoMessage(failedVideo.videoName, failedVideo.message));
-                        }
-                        logger.warn(`Not all recordings succeeded to upload. Failed videos: ${failedVideoNames.join(', ') || 'unknown'}. Some videos may be missing from the project.`);
-                        if (playwrightFailure === null) {
-                            throw new PartialUploadError();
-                        }
-                    }
+                    throw new RecordFailureHintError(error);
                 }
             }
-            catch (err) {
-                if (isPartialUploadError(err)) {
-                    throw err;
-                }
-                logger.warn('Failed to load config for upload:', err);
-            }
         }
+        else {
+            logger.info('UPLOAD_EXISTING set: skipping Playwright recording and re-uploading existing .screenci recordings.');
+        }
+        if (process.env.SCREENCI_RECORDING === 'true')
+            return;
+        await uploadRecordedVideosForConfig(parsed.configPath, playwrightFailure, parsed.verbose);
         if (playwrightFailure !== null) {
             throw playwrightFailure;
         }
@@ -1948,6 +2411,13 @@ export async function main() {
         const recordCommand = getSuggestedScreenciCommand('record');
         logger.info(`Tests passed. Run ${pc.cyan(recordCommand)} to render the videos.`);
     });
+    program
+        .command('login')
+        .description('Open the sign-in link in your browser (best-effort) so recording can finish later')
+        .option('-c, --config <path>', 'path to screenci.config.ts')
+        .action(async (options) => {
+        await runLogin(options['config']);
+    });
     program
         .command('info')
         .description("Print the latest record run's video URLs and render status as JSON")
@@ -2132,7 +2602,7 @@ function validateArgs(args) {
 }
 /**
  * Fetch the project's current Studio text-field overrides so they can be
- * injected as SCREENCI_TEXT_OVERRIDES before a recording. On-screen `text`
+ * injected as SCREENCI_VALUES_OVERRIDES before a recording. On-screen `values`
  * fields render during the recording (they cannot be patched at render time),
  * so any Studio edits must be present here; code-declared seeds are the
  * fallback. Best-effort: any failure returns an empty env so the SDK uses the
@@ -2161,7 +2631,7 @@ async function fetchTextOverridesEnv(configPath, languages, verbose) {
             Object.keys(overrides).length === 0) {
             return {};
         }
-        return { [SCREENCI_TEXT_OVERRIDES_ENV]: JSON.stringify(overrides) };
+        return { [SCREENCI_VALUES_OVERRIDES_ENV]: JSON.stringify(overrides) };
     }
     catch (error) {
         if (verbose) {