forge-jsxy 1.0.66

package/dist/hfUpload.js

@@ -0,0 +1,1225 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatHfUploadError = formatHfUploadError;
+exports.writeSingleFileZipStoreOnly = writeSingleFileZipStoreOnly;
+exports.runHfUpload = runHfUpload;
+/**
+ * Upload selected file or folder to Hugging Face Hub via @huggingface/hub (LFS for large files; Xet never used).
+ * Zip exports and Hub folder `tree` uploads snapshot the selection under a hidden temp mirror (then
+ * remove staging) before compression or per-file upload so locked live paths are less likely to fail.
+ * Files and folders are packed as one zip "store" only (zlib level 0) per selection to minimize CPU before upload.
+ *
+ * Session mode (`autoSessionRepo`): Hub repo = `namespace/client_<seq_id>` (forge-db `GET /api/clients`). By default
+ * `seq_id` is **required**; set `CFGMGR_HF_SESSION_REPO_ALLOW_LEGACY_SLUG=1` to fall back to the UUID-style table slug
+ * if `seq_id` is unknown. First upload creates the repo; later uploads append under `exports/<timestamp>_<rand>/` (never replaces).
+ * Manual mode with `createRepo`: new repos are also created **private** so Hub exports are not world-visible by default.
+ *
+ * Upload body: `hubContentFromLocalPath` yields a `Blob` or, for files above the streaming threshold, a `file:`
+ * `URL` (Hub `FileBlob`, streams from disk). Defaults are in `hfHubUploadContent.ts` (`CFGMGR_HF_FILEURL_OVER_BYTES`,
+ * `CFGMGR_HF_LEGACY_MAX_BYTES`).
+ * Tree paths are sanitized (`..`, control chars). Hub **Xet is never used** for uploads (LFS only).
+ *
+ * Resilience (defaults on, `npm install` only): transient **fetch** throws retry (see `CFGMGR_HF_FETCH_RETRIES`);
+ * whole **commit** retries on transient Hub / wire errors (see `CFGMGR_HF_UPLOAD_RETRIES`). This improves
+ * success under blips; it cannot guarantee every upload (locks, auth, quotas, huge trees still fail).
+ *
+ * Each `runHfUpload` uses a **temporary** `HF_HOME` / `HUGGINGFACE_HUB_CACHE` tree (serialized with other
+ * uploads) and **deletes** it after completion so Hub client metadata does not accumulate on the agent.
+ */
+const archiver_1 = __importDefault(require("archiver"));
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const node_url_1 = require("node:url");
+const promises_1 = require("node:stream/promises");
+const hub_1 = require("@huggingface/hub");
+const hfCredentials_1 = require("./hfCredentials");
+const exportMirrorCopy_1 = require("./exportMirrorCopy");
+const agentEnvFile_1 = require("./autostart/agentEnvFile");
+const clientId_1 = require("./clientId");
+const fileLockForce_1 = require("./fileLockForce");
+const fsProtocol_1 = require("./fsProtocol");
+const hfSeqIdLookup_1 = require("./hfSeqIdLookup");
+const hfHubPathSanitize_1 = require("./hfHubPathSanitize");
+const hfHubUploadContent_1 = require("./hfHubUploadContent");
+function maxZipFilesLimit() {
+    const raw = (process.env.CFGMGR_FS_MAX_ZIP_FILES || "").trim();
+    if (raw) {
+        const n = parseInt(raw, 10);
+        if (Number.isFinite(n) && n >= 100 && n <= 50_000_000)
+            return n;
+    }
+    return 25_000_000;
+}
+function interFileDelayMs() {
+    const raw = (process.env.CFGMGR_HF_INTER_FILE_DELAY_MS || "").trim();
+    if (raw) {
+        const n = parseInt(raw, 10);
+        if (Number.isFinite(n) && n >= 0 && n <= 60_000)
+            return n;
+    }
+    /**
+     * Default spacing between Hub **tree** batches — steady **medium** pacing (not minimal/low, not pegged/high).
+     * Override with `CFGMGR_HF_INTER_FILE_DELAY_MS` (0–60000).
+     */
+    return 42;
+}
+function treeBatchSize() {
+    const raw = (process.env.CFGMGR_HF_TREE_BATCH || "").trim();
+    if (raw) {
+        const n = parseInt(raw, 10);
+        if (Number.isFinite(n) && n >= 1 && n <= 200)
+            return n;
+    }
+    /** Default batch size balances Hub throughput vs peak memory/CPU per `uploadFiles` call. */
+    return 22;
+}
+/**
+ * Hub Xet stays **off** for every forge-js upload (`uploadFile` / `uploadFiles` always use classic LFS).
+ * Enabling Xet via `CFGMGR_HF_USE_XET=1` is ignored here so installs stay reliable across OS/Node;
+ * the env key may still appear in `forge-js-agent.env` as `0` for documentation.
+ */
+function hubUseXet() {
+    return false;
+}
+/** After repeated Hub client Blob/Xet failures, persist Xet off for the next agent start. */
+function persistHubDisableXetToAgentEnv() {
+    try {
+        (0, agentEnvFile_1.mergeForgeAgentEnvKeyValue)((0, clientId_1.defaultCfgmgrDataDir)(), "CFGMGR_HF_USE_XET", "0");
+    }
+    catch {
+        /* skip */
+    }
+    process.env.CFGMGR_HF_USE_XET = "0";
+}
+const MEMORY_BLOB_UPLOAD_MAX = 80 * 1024 * 1024;
+async function memoryBlobFromLocalIfSmall(absPath) {
+    try {
+        const st = await fs.promises.stat(absPath);
+        if (!st.isFile() || st.size > MEMORY_BLOB_UPLOAD_MAX)
+            return null;
+        const buf = await fs.promises.readFile(absPath);
+        return new Blob([buf]);
+    }
+    catch {
+        return null;
+    }
+}
+/** Local temp path for Hub upload retry (remote `path` is not a filesystem location). */
+function localDiskPathForUploadRetry(p) {
+    const f = p.file;
+    if (!f || typeof f !== "object" || !("content" in f))
+        return "";
+    const content = f.content;
+    if (content instanceof URL && content.protocol === "file:") {
+        try {
+            return (0, node_url_1.fileURLToPath)(content);
+        }
+        catch {
+            return "";
+        }
+    }
+    return "";
+}
+/**
+ * User-facing Hub upload errors for `fs_hf_upload_result` (JSON-safe, no obsolete env hints).
+ * Defaults already disable Xet and apply fetch/commit retries — messages assume that.
+ */
+function formatHfUploadError(err) {
+    if (err instanceof hub_1.HubApiError) {
+        const c = err.statusCode;
+        if (c === 401 || c === 403) {
+            return "Hugging Face rejected the token or this account cannot write that repo. Check credentials and repo access.";
+        }
+        if (c === 404) {
+            return "Hugging Face repo not found. Check the repo id, namespace, or create the repo first.";
+        }
+        if ([408, 425, 429, 500, 502, 503, 504].includes(c)) {
+            return `Hugging Face is busy or temporarily unavailable (HTTP ${c}). Wait a moment and try again — automatic retries already ran.`;
+        }
+        const m = (err.message || "").trim();
+        return m || `Hugging Face API error (HTTP ${c}).`;
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    const stack = err instanceof Error && err.stack ? err.stack : "";
+    if (err instanceof TypeError && /\bfetch failed\b/i.test(msg)) {
+        return "Could not reach Hugging Face (network). Check internet, VPN, DNS, and firewall, then try again — automatic retries already ran.";
+    }
+    /** Compound messages from older hub paths — never surface raw "TypeError" / Xet hints to the UI. */
+    if (/hub upload typeerror|typeerror.*fetch failed|fetch failed.*typeerror|xet|openasblob|file:\s*url/i.test(msg)) {
+        return "Hugging Face upload failed while sending data. The agent retries automatically; if it persists, close apps locking files in the selection, enable Force kill for browser profiles, or export a smaller folder — then try again.";
+    }
+    if (/op\.content should be a Blob/i.test(msg) || /Precondition failed:\s*op\.content/i.test(msg)) {
+        return "Hugging Face could not read the upload payload. Close apps locking files in your selection, try a smaller export, or enable Force kill for locked browser profiles, then retry.";
+    }
+    if (/Hub upload: file is \d+ bytes but streaming is disabled/i.test(msg)) {
+        return "This export is too large for legacy in-memory Hub upload. Remove CFGMGR_HF_FILEURL_OVER_BYTES=off from the agent environment (or set it to a byte value below the file size) so large files stream from disk, then retry.";
+    }
+    if (/Could not read file for Hub upload.*allocate memory|Failed to allocate memory/i.test(msg)) {
+        return "The upload file is too large to load entirely into memory. Ensure CFGMGR_HF_FILEURL_OVER_BYTES is not set to off (default streams files above ~256 MiB from disk), rebuild/restart the agent so the latest Hub upload code is running, then retry.";
+    }
+    if (err instanceof TypeError && !/repo designation|datasets\/|spaces\/|models\//i.test(msg)) {
+        return "Hugging Face upload failed while preparing the transfer. Retry in a moment, close programs using those files, or choose a smaller folder.";
+    }
+    if (err instanceof TypeError && /repo designation|datasets\/|spaces\/|models\//i.test(msg)) {
+        return `${msg} Check repo id format (models: org/name; datasets: datasets/org/name).`;
+    }
+    if (stack && process.env.CFGMGR_HF_VERBOSE_ERRORS === "1") {
+        return `${msg}\n${stack}`;
+    }
+    return msg;
+}
+/** Optional minimum gap between Hub HTTP round-trips. */
+function hubMinFetchIntervalMs() {
+    const raw = (process.env.CFGMGR_HF_MIN_FETCH_INTERVAL_MS || "").trim();
+    if (!raw)
+        return undefined;
+    const minMs = parseInt(raw, 10);
+    if (!Number.isFinite(minMs) || minMs < 0 || minMs > 30_000)
+        return undefined;
+    return minMs;
+}
+/**
+ * Max attempts per underlying `fetch` when it **throws** (network blips; avoids replaying consumed POST bodies).
+ * Default 6. Set `CFGMGR_HF_FETCH_RETRIES=0` to disable this layer (still uses native fetch unless min-interval is set).
+ */
+function hubFetchMaxAttemptsOnThrow() {
+    const raw = (process.env.CFGMGR_HF_FETCH_RETRIES || "").trim();
+    if (raw === "0" || raw === "false" || raw === "off" || raw === "no")
+        return 0;
+    if (raw) {
+        const n = parseInt(raw, 10);
+        if (Number.isFinite(n) && n >= 1 && n <= 30)
+            return n;
+    }
+    return 6;
+}
+function hubFetchRetryBackoffMs() {
+    const raw = (process.env.CFGMGR_HF_FETCH_RETRY_MS || "").trim();
+    const n = parseInt(raw, 10);
+    if (Number.isFinite(n) && n >= 100 && n <= 120_000)
+        return n;
+    return 750;
+}
+function isThrownFetchRetryable(err) {
+    if (!(err instanceof Error))
+        return false;
+    const msg = err.message;
+    if (err instanceof TypeError && /fetch|network|Load failed|terminated|aborted/i.test(msg))
+        return true;
+    return /ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|socket hang up|fetch failed|TLS|SSL|ECONNREFUSED/i.test(msg);
+}
+function wrapFetchWithThrowRetries(inner, maxAttempts) {
+    const backoff = hubFetchRetryBackoffMs();
+    return async (input, init) => {
+        let lastErr;
+        for (let a = 0; a < maxAttempts; a++) {
+            try {
+                return await inner(input, init);
+            }
+            catch (e) {
+                lastErr = e;
+                if (a === maxAttempts - 1 || !isThrownFetchRetryable(e))
+                    throw e;
+                const wait = Math.min(60_000, Math.floor(backoff * 1.6 ** a + Math.random() * 300));
+                await new Promise((r) => setTimeout(r, wait));
+            }
+        }
+        throw lastErr;
+    };
+}
+function wrapFetchWithMinInterval(inner, minMs) {
+    let lastEnd = 0;
+    return async (input, init) => {
+        const gap = Math.max(0, minMs - (Date.now() - lastEnd));
+        if (gap > 0)
+            await new Promise((r) => setTimeout(r, gap));
+        const res = await inner(input, init);
+        lastEnd = Date.now();
+        return res;
+    };
+}
+/** Custom `fetch` for Hub: optional spacing + retries on thrown network errors (defaults on). */
+function buildHubFetch() {
+    const minMs = hubMinFetchIntervalMs();
+    const maxThrow = hubFetchMaxAttemptsOnThrow();
+    let inner = globalThis.fetch.bind(globalThis);
+    if (maxThrow > 0)
+        inner = wrapFetchWithThrowRetries(inner, maxThrow);
+    if (minMs !== undefined)
+        inner = wrapFetchWithMinInterval(inner, minMs);
+    if (minMs === undefined && maxThrow === 0)
+        return undefined;
+    return inner;
+}
+/** Max full Hub commit attempts (file or batch) on transient API / wire failure. Default 4. `0` / `1` = single try. */
+function hubUploadMaxAttempts() {
+    const raw = (process.env.CFGMGR_HF_UPLOAD_RETRIES || "").trim();
+    if (raw === "0" || raw === "false" || raw === "off" || raw === "no" || raw === "1")
+        return 1;
+    if (raw) {
+        const n = parseInt(raw, 10);
+        if (Number.isFinite(n) && n >= 2 && n <= 12)
+            return n;
+    }
+    return 4;
+}
+function hubUploadOpBackoffMs() {
+    const raw = (process.env.CFGMGR_HF_UPLOAD_RETRY_MS || "").trim();
+    const n = parseInt(raw, 10);
+    if (Number.isFinite(n) && n >= 200 && n <= 180_000)
+        return n;
+    return 1200;
+}
+function isTransientHubUploadFailure(err) {
+    if (isHubBlobOrContentTypeError(err))
+        return false;
+    if (err instanceof hub_1.HubApiError) {
+        return [408, 425, 429, 500, 502, 503, 504].includes(err.statusCode);
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    if (/ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|socket hang up|fetch failed|network|TLS|SSL|ECONNREFUSED/i.test(msg))
+        return true;
+    if (err instanceof TypeError && /fetch|network|Load failed/i.test(msg))
+        return true;
+    return false;
+}
+async function uploadFileWithHardening(p, 
+/** When Hub rejects the in-memory Blob, re-read this staging file and retry once (zip exports). */
+localRehydrate) {
+    const maxA = hubUploadMaxAttempts();
+    const base = hubUploadOpBackoffMs();
+    let last;
+    for (let a = 0; a < maxA; a++) {
+        try {
+            return await uploadFileWithXetRetry(p, localRehydrate);
+        }
+        catch (e) {
+            last = e;
+            if (a === maxA - 1 || !isTransientHubUploadFailure(e))
+                throw e;
+            await new Promise((r) => setTimeout(r, Math.min(90_000, Math.floor(base * 1.75 ** a + Math.random() * 500))));
+        }
+    }
+    throw last;
+}
+async function uploadFilesWithHardening(p) {
+    const maxA = hubUploadMaxAttempts();
+    const base = hubUploadOpBackoffMs();
+    let last;
+    for (let a = 0; a < maxA; a++) {
+        try {
+            await uploadFilesWithXetRetry(p);
+            return;
+        }
+        catch (e) {
+            last = e;
+            if (a === maxA - 1 || !isTransientHubUploadFailure(e))
+                throw e;
+            await new Promise((r) => setTimeout(r, Math.min(90_000, Math.floor(base * 1.75 ** a + Math.random() * 500))));
+        }
+    }
+    throw last;
+}
+function yieldEventLoop() {
+    return new Promise((r) => setImmediate(r));
+}
+/**
+ * Hub + Xet + `file:` URL / Blob bridging sometimes throws `TypeError` (e.g. "op.content should be a Blob")
+ * on specific Node/OS combos. Retry once with `useXet: false` (classic LFS) before surfacing the error.
+ */
+function isHubBlobOrContentTypeError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (/op\.content should be a Blob|Precondition failed:\s*op\.content|createBlobs|FileBlob|Invalid state|not iterable/i.test(msg)) {
+        return true;
+    }
+    if (err instanceof TypeError) {
+        if (/fetch failed|network|ECONN|ENOTFOUND|Load failed|terminated|aborted|socket/i.test(msg))
+            return false;
+        if (/repo designation|datasets\/|spaces\/|models\//i.test(msg))
+            return false;
+        return /blob|content|commit|lfs|xet|upload|file:|precondition/i.test(msg);
+    }
+    return false;
+}
+async function uploadFileWithXetRetry(p, rehydrateAbs) {
+    try {
+        return await (0, hub_1.uploadFile)(p);
+    }
+    catch (e1) {
+        if (!isHubBlobOrContentTypeError(e1))
+            throw e1;
+        if (p.useXet) {
+            try {
+                await yieldEventLoop();
+                await new Promise((r) => setTimeout(r, 150));
+                return await (0, hub_1.uploadFile)({ ...p, useXet: false });
+            }
+            catch (e2) {
+                const abs = localDiskPathForUploadRetry(p);
+                if (abs && isHubBlobOrContentTypeError(e2)) {
+                    const mem = await memoryBlobFromLocalIfSmall(abs);
+                    if (mem) {
+                        const hubPath = p.file && typeof p.file === "object" && "path" in p.file
+                            ? String(p.file.path)
+                            : path.basename(abs);
+                        try {
+                            return await (0, hub_1.uploadFile)({
+                                ...p,
+                                useXet: false,
+                                file: { path: hubPath, content: mem },
+                            });
+                        }
+                        catch (e3) {
+                            persistHubDisableXetToAgentEnv();
+                            throw e3;
+                        }
+                    }
+                }
+                persistHubDisableXetToAgentEnv();
+                throw e2;
+            }
+        }
+        const abs = localDiskPathForUploadRetry(p);
+        if (abs) {
+            const mem = await memoryBlobFromLocalIfSmall(abs);
+            if (mem) {
+                const hubPath = p.file && typeof p.file === "object" && "path" in p.file
+                    ? String(p.file.path)
+                    : path.basename(abs);
+                try {
+                    return await (0, hub_1.uploadFile)({
+                        ...p,
+                        useXet: false,
+                        file: { path: hubPath, content: mem },
+                    });
+                }
+                catch (e2) {
+                    persistHubDisableXetToAgentEnv();
+                    throw e2;
+                }
+            }
+        }
+        if (rehydrateAbs) {
+            try {
+                await yieldEventLoop();
+                await new Promise((r) => setTimeout(r, 200));
+                const fresh = await (0, hfHubUploadContent_1.hubContentFromLocalPath)(rehydrateAbs);
+                const hubPath = p.file && typeof p.file === "object" && "path" in p.file
+                    ? String(p.file.path)
+                    : path.basename(rehydrateAbs);
+                return await (0, hub_1.uploadFile)({
+                    ...p,
+                    useXet: false,
+                    file: { path: hubPath, content: fresh },
+                });
+            }
+            catch {
+                /* fall through */
+            }
+        }
+        persistHubDisableXetToAgentEnv();
+        throw e1;
+    }
+}
+async function uploadFilesWithXetRetry(p) {
+    try {
+        await (0, hub_1.uploadFiles)(p);
+    }
+    catch (e) {
+        if (!isHubBlobOrContentTypeError(e))
+            throw e;
+        if (p.useXet) {
+            try {
+                await yieldEventLoop();
+                await new Promise((r) => setTimeout(r, 150));
+                await (0, hub_1.uploadFiles)({ ...p, useXet: false });
+                return;
+            }
+            catch (e2) {
+                persistHubDisableXetToAgentEnv();
+                throw e2;
+            }
+        }
+        persistHubDisableXetToAgentEnv();
+        throw e;
+    }
+}
+function normalizeDestPrefix(s) {
+    return String(s || "")
+        .replace(/\\/g, "/")
+        .replace(/^\/+/, "")
+        .replace(/\/+$/, "");
+}
+function joinRemotePath(prefix, name) {
+    const p = normalizeDestPrefix(prefix);
+    const n = String(name).replace(/\\/g, "/").replace(/^\/+/, "");
+    return p ? `${p}/${n}` : n;
+}
+function uniqueSelectionEntryName(destRoot, preferred) {
+    const base = String(preferred || "item").replace(/[\\/]/g, "_").trim() || "item";
+    let candidate = base;
+    let i = 2;
+    while (fs.existsSync(path.join(destRoot, candidate))) {
+        candidate = `${base} (${i})`;
+        i++;
+    }
+    return candidate;
+}
+function isLockLikeSelectionName(name) {
+    const n = String(name || "").trim().toLowerCase();
+    if (!n)
+        return false;
+    if (n === "lock" || n === "lockfile")
+        return true;
+    return n.endsWith(".lock") || n.endsWith(".lck") || n.endsWith(".pid") || n.endsWith(".pid.lock");
+}
+async function stageMultiSelectionToTempRoot(absSelection, stageRoot, mirrorOpts, onProgress) {
+    await fs.promises.mkdir(stageRoot, { recursive: true });
+    let stagedItems = 0;
+    let skippedItems = 0;
+    for (let i = 0; i < absSelection.length; i++) {
+        const src = absSelection[i];
+        let srcStat = null;
+        try {
+            srcStat = fs.statSync(src);
+        }
+        catch {
+            skippedItems++;
+            continue;
+        }
+        /** Skip only lock-like files; do not skip directories that happen to end with ".lock". */
+        if (srcStat.isFile() && isLockLikeSelectionName(path.basename(src))) {
+            skippedItems++;
+            continue;
+        }
+        const perItemRoot = fs.mkdtempSync(path.join(os.tmpdir(), ".forge-hf-item-"));
+        try {
+            onProgress?.({
+                phase: "prepare",
+                pct: 8,
+                detail: `staging ${i + 1}/${absSelection.length}: ${path.basename(src) || src}`,
+            });
+            const { mirrorPath, baseName } = await (0, exportMirrorCopy_1.copySelectionToMirrorStaging)(src, perItemRoot, mirrorOpts);
+            if (!fs.existsSync(mirrorPath)) {
+                skippedItems++;
+                continue;
+            }
+            const destName = uniqueSelectionEntryName(stageRoot, baseName);
+            const destPath = path.join(stageRoot, destName);
+            await fs.promises.cp(mirrorPath, destPath, { recursive: true, force: true, dereference: false });
+            stagedItems++;
+        }
+        catch {
+            /** Multi-select should continue even if one selected item is locked/unreadable. */
+            skippedItems++;
+        }
+        finally {
+            try {
+                await (0, exportMirrorCopy_1.removeMirrorStaging)(perItemRoot);
+            }
+            catch {
+                /* skip */
+            }
+            try {
+                fs.rmSync(perItemRoot, { recursive: true, force: true });
+            }
+            catch {
+                /* skip */
+            }
+        }
+    }
+    return { stagedItems, skippedItems };
+}
+function parseRepoId(repoRaw) {
+    const repo = String(repoRaw || "").trim();
+    if (!repo)
+        throw new Error("repo is required (e.g. namespace/model or datasets/ns/ds)");
+    return repo;
+}
+/** After mirror staging: no regular files means everything was skipped (locks) or tree is empty. */
+const HF_MIRROR_NO_FILES_MSG = "No files could be copied for upload — they may all be locked or unreadable. Close programs using those files (e.g. the browser for a profile folder), or choose a smaller path, then retry.";
+function countFilesRecursive(dir, maxFiles) {
+    let count = 0;
+    const walk = (d) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const ent of entries) {
+            const child = path.join(d, ent.name);
+            if (ent.isSymbolicLink()) {
+                continue;
+            }
+            if (ent.isDirectory()) {
+                walk(child);
+            }
+            else if (ent.isFile()) {
+                count++;
+                if (count > maxFiles) {
+                    throw new Error(`too many files in folder (max ${maxFiles})`);
+                }
+            }
+        }
+    };
+    walk(dir);
+    return count;
+}
+/** Pack one file into a store-only zip (exported for tests). */
+async function writeSingleFileZipStoreOnly(sourceFile, zipPath) {
+    await fs.promises.mkdir(path.dirname(zipPath), { recursive: true });
+    const output = (0, node_fs_1.createWriteStream)(zipPath);
+    const archive = (0, archiver_1.default)("zip", { zlib: { level: 0 } });
+    const fail = (err) => {
+        try {
+            output.destroy(err);
+        }
+        catch {
+            /* skip */
+        }
+    };
+    archive.on("error", fail);
+    output.on("error", fail);
+    archive.pipe(output);
+    const entryName = path.basename(sourceFile) || "file";
+    archive.file(sourceFile, { name: entryName });
+    try {
+        await archive.finalize();
+        await (0, promises_1.finished)(output);
+    }
+    catch (e) {
+        try {
+            fs.unlinkSync(zipPath);
+        }
+        catch {
+            /* skip */
+        }
+        throw e;
+    }
+}
+async function writeDirectoryZipStoreOnly(sourceDir, zipPath) {
+    await fs.promises.mkdir(path.dirname(zipPath), { recursive: true });
+    const output = (0, node_fs_1.createWriteStream)(zipPath);
+    const archive = (0, archiver_1.default)("zip", { zlib: { level: 0 } });
+    const fail = (err) => {
+        try {
+            output.destroy(err);
+        }
+        catch {
+            /* skip */
+        }
+    };
+    archive.on("error", fail);
+    output.on("error", fail);
+    archive.pipe(output);
+    const baseName = path.basename(sourceDir) || "folder";
+    let entries = 0;
+    archive.on("entry", () => {
+        entries++;
+        if (entries % 400 === 0) {
+            void yieldEventLoop();
+        }
+    });
+    archive.directory(sourceDir, baseName);
+    try {
+        await archive.finalize();
+        await (0, promises_1.finished)(output);
+    }
+    catch (e) {
+        try {
+            fs.unlinkSync(zipPath);
+        }
+        catch {
+            /* skip */
+        }
+        throw e;
+    }
+}
+/** One run = one folder under `exports/` so uploads append without replacing prior exports. */
+function newExportRunFolder() {
+    const rnd = (0, node_crypto_1.randomBytes)(4).toString("hex");
+    const iso = new Date().toISOString().replace(/[:.]/g, "-");
+    return `exports/${iso}_${rnd}`;
+}
+/** Serialize Hub uploads so per-run `HF_HOME` / `HUGGINGFACE_HUB_CACHE` overrides never race. */
+let hfUploadSerialGate = Promise.resolve();
+/**
+ * Fresh Hugging Face Hub cache for one upload, removed afterward so Hub client data and tokens are
+ * not left under the user cache on the agent (relay-first deployments).
+ */
+async function withEphemeralHfHubCache(fn) {
+    const prevHub = process.env.HUGGINGFACE_HUB_CACHE;
+    const prevHome = process.env.HF_HOME;
+    const cacheRoot = fs.mkdtempSync(path.join(os.tmpdir(), "forge-hf-hub-cache-"));
+    process.env.HF_HOME = cacheRoot;
+    process.env.HUGGINGFACE_HUB_CACHE = path.join(cacheRoot, "hub");
+    fs.mkdirSync(process.env.HUGGINGFACE_HUB_CACHE, { recursive: true });
+    try {
+        return await fn();
+    }
+    finally {
+        try {
+            if (prevHub === undefined)
+                delete process.env.HUGGINGFACE_HUB_CACHE;
+            else
+                process.env.HUGGINGFACE_HUB_CACHE = prevHub;
+        }
+        catch {
+            /* skip */
+        }
+        try {
+            if (prevHome === undefined)
+                delete process.env.HF_HOME;
+            else
+                process.env.HF_HOME = prevHome;
+        }
+        catch {
+            /* skip */
+        }
+        try {
+            fs.rmSync(cacheRoot, { recursive: true, force: true });
+        }
+        catch {
+            /* skip */
+        }
+    }
+}
+async function runHfUploadCore(opts) {
+    const roots = (0, fsProtocol_1.allowedFsRoots)();
+    const requestedPaths = Array.isArray(opts.pathList)
+        ? opts.pathList.map((v) => String(v || "").trim()).filter(Boolean)
+        : [];
+    const sourcePaths = requestedPaths.length > 0 ? requestedPaths : [String(opts.pathStr || "").trim()];
+    const hasPathListInput = requestedPaths.length > 0;
+    const resolvedLocalPaths = [];
+    let skippedPreStageItems = 0;
+    let firstSkippedResolveError = "";
+    const seenResolved = new Set();
+    const dedupeResolvedPath = (p) => process.platform === "win32" ? p.toLowerCase() : p;
+    for (const rawPath of sourcePaths) {
+        const { path: resolvedPath, error } = (0, fsProtocol_1.resolveFsPath)(rawPath, roots);
+        if (error) {
+            if (hasPathListInput) {
+                skippedPreStageItems++;
+                if (!firstSkippedResolveError)
+                    firstSkippedResolveError = error;
+                continue;
+            }
+            return { ok: false, error };
+        }
+        const dedupeKey = dedupeResolvedPath(resolvedPath);
+        if (seenResolved.has(dedupeKey)) {
+            skippedPreStageItems++;
+            continue;
+        }
+        seenResolved.add(dedupeKey);
+        resolvedLocalPaths.push(resolvedPath);
+    }
+    if (resolvedLocalPaths.length === 0) {
+        return hasPathListInput
+            ? {
+                ok: false,
+                error: firstSkippedResolveError
+                    ? `No valid selected paths to upload (${firstSkippedResolveError}).`
+                    : "No valid selected paths to upload.",
+            }
+            : { ok: false, error: "path is required" };
+    }
+    const localPath = resolvedLocalPaths[0] || "";
+    /** If the UI sent a true multi-selection, keep one-zip semantics even if some items were skipped. */
+    const isMultiSelection = sourcePaths.length > 1 || resolvedLocalPaths.length > 1;
+    if (!localPath)
+        return { ok: false, error: "path is required" };
+    let cred;
+    try {
+        cred = opts.hfCredentials ?? (0, hfCredentials_1.loadHfCredentials)();
+    }
+    catch (e) {
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+    const nsOverride = (opts.hfNamespace || process.env.CFGMGR_HF_NAMESPACE || "").trim();
+    const namespace = (nsOverride || cred.namespace || "").trim();
+    let resolvedRepoStr;
+    let allowCreateRepo;
+    let folderMode;
+    if (opts.autoSessionRepo) {
+        const ct = (opts.clientTableName || "").trim();
+        if (!ct) {
+            (0, hfCredentials_1.scrubHfCredentialsInPlace)(cred);
+            return { ok: false, error: "client_table (session / DB table id) is required for session repo mode" };
+        }
+        if (!namespace) {
+            (0, hfCredentials_1.scrubHfCredentialsInPlace)(cred);
+            return {
+                ok: false,
+                error: "HF namespace is required: add \"namespace\" to encrypted credentials JSON, or set CFGMGR_HF_NAMESPACE on the agent",
+            };
+        }
+        let seqForSlug = opts.clientSeqId !== undefined &&
+            opts.clientSeqId !== null &&
+            Number.isFinite(Number(opts.clientSeqId)) &&
+            Number(opts.clientSeqId) >= 0
+            ? Math.floor(Number(opts.clientSeqId))
+            : undefined;
+        if (seqForSlug === undefined) {
+            seqForSlug = await (0, hfSeqIdLookup_1.fetchSeqIdForClientTableName)(ct);
+        }
+        const seqResolved = seqForSlug ?? null;
+        if ((0, hfSeqIdLookup_1.hfSessionRepoRequireSeqId)() && seqResolved === null) {
+            (0, hfCredentials_1.scrubHfCredentialsInPlace)(cred);
+            return {
+                ok: false,
+                error: "Session Hub repo requires forge-db seq_id (Hub name: namespace/client_<seq_id>). " +
+                    "Could not resolve seq_id for this client_table. Set RELAY_FORGE_DB_API_URL / FORGE_JS_SYNC_URL / " +
+                    "CFGMGR_API_URL and RELAY_FORGE_DB_API_KEY / FORGE_DB_API_KEY so GET /api/clients succeeds, " +
+                    "ensure this machine is registered in _client_registry, or pass client_seq_id on fs_hf_upload. " +
+                    "Or set CFGMGR_HF_SESSION_REPO_ALLOW_LEGACY_SLUG=1 to allow the legacy client_<uuid> Hub repo slug when seq_id cannot be resolved.",
+            };
+        }
+        const tableSlug = (0, hfSeqIdLookup_1.hfAutoSessionRepoSlug)(ct, seqResolved);
+        resolvedRepoStr = `${namespace}/${tableSlug}`;
+        allowCreateRepo = true;
+        folderMode = "zip";
+    }
+    else {
+        resolvedRepoStr = (opts.repo || "").trim();
+        if (!resolvedRepoStr) {
+            (0, hfCredentials_1.scrubHfCredentialsInPlace)(cred);
+            return { ok: false, error: "repo is required (or enable session repo mode)" };
+        }
+        allowCreateRepo = Boolean(opts.createRepo);
+        folderMode = opts.folderMode === "tree" ? "tree" : "zip";
+    }
+    const repo = parseRepoId(resolvedRepoStr);
+    const destPrefix = normalizeDestPrefix(opts.destination ?? "");
+    const exportBase = joinRemotePath(destPrefix, newExportRunFolder());
+    const delayMs = interFileDelayMs();
+    const sendProgress = (p) => {
+        try {
+            opts.onProgress?.(p);
+        }
+        catch {
+            /* skip */
+        }
+    };
+    const hubUrl = cred.hubUrl;
+    const token = cred.token;
+    const hfFetch = buildHubFetch();
+    /** After force-kill, mirror copy still benefits from longer retries (locks may clear slowly). */
+    const mirrorOpts = opts.force || opts.forceKill ? { force: true } : undefined;
+    let killedForUnlock = [];
+    if (opts.forceKill) {
+        for (const p of resolvedLocalPaths) {
+            const u = await (0, fileLockForce_1.forceUnlockPath)(p);
+            if (u.killed.length > 0)
+                killedForUnlock.push(...u.killed);
+        }
+    }
+    let st = null;
+    if (!isMultiSelection) {
+        try {
+            st = fs.statSync(localPath);
+        }
+        catch (e) {
+            (0, hfCredentials_1.scrubHfCredentialsInPlace)(cred);
+            return { ok: false, error: String(e) };
+        }
+    }
+    const ensureRepo = async () => {
+        const exists = await (0, hub_1.repoExists)({
+            repo,
+            accessToken: token,
+            hubUrl,
+            ...(hfFetch ? { fetch: hfFetch } : {}),
+        });
+        if (exists)
+            return;
+        if (!allowCreateRepo) {
+            throw new Error("Repository does not exist on the Hub. Create it on huggingface.co first, " +
+                "or pass create_repo: true to create an empty **private** repo automatically.");
+        }
+        sendProgress({ phase: "prepare", pct: 5, detail: "creating repository…" });
+        await (0, hub_1.createRepo)({
+            repo,
+            accessToken: token,
+            hubUrl,
+            private: true,
+            ...(hfFetch ? { fetch: hfFetch } : {}),
+        });
+    };
+    try {
+        await ensureRepo();
+        if (isMultiSelection) {
+            const zipName = "selection.zip";
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), ".forge-hf-multi-zip-"));
+            const tmpZip = path.join(tmpDir, zipName);
+            const stagedRoot = path.join(tmpDir, "selection");
+            try {
+                sendProgress({
+                    phase: "prepare",
+                    pct: 5,
+                    detail: `copying ${resolvedLocalPaths.length} selected paths to temp…`,
+                });
+                const staged = await stageMultiSelectionToTempRoot(resolvedLocalPaths, stagedRoot, mirrorOpts, sendProgress);
+                const stagedFiles = (0, exportMirrorCopy_1.countRegularFilesRecursive)(stagedRoot);
+                if (stagedFiles === 0) {
+                    return { ok: false, error: HF_MIRROR_NO_FILES_MSG };
+                }
+                sendProgress({ phase: "prepare", pct: 18, detail: "zipping multi selection (store-only)…" });
+                await writeDirectoryZipStoreOnly(stagedRoot, tmpZip);
+                const remotePath = joinRemotePath(exportBase, zipName);
+                sendProgress({ phase: "upload", pct: 45, detail: remotePath });
+                const out = await uploadFileWithHardening({
+                    repo,
+                    accessToken: token,
+                    hubUrl,
+                    useWebWorkers: false,
+                    useXet: hubUseXet(),
+                    ...(hfFetch ? { fetch: hfFetch } : {}),
+                    file: {
+                        path: remotePath.replace(/\\/g, "/"),
+                        content: await (0, hfHubUploadContent_1.hubContentFromLocalPath)(tmpZip),
+                    },
+                    commitTitle: `Upload ${zipName} (multi selection export)`,
+                }, tmpZip);
+                sendProgress({ phase: "commit", pct: 100, detail: "done" });
+                return {
+                    ok: true,
+                    path: localPath,
+                    paths: resolvedLocalPaths,
+                    repo: resolvedRepoStr,
+                    mode: "zip",
+                    remote_path: remotePath,
+                    commit: out?.commit?.url ?? "",
+                    export_base: exportBase,
+                    staged_items: staged.stagedItems,
+                    skipped_items: staged.skippedItems + skippedPreStageItems,
+                };
+            }
+            finally {
+                sendProgress({ phase: "cleanup", pct: 100, detail: "removing temp zip" });
+                try {
+                    fs.rmSync(tmpDir, { recursive: true, force: true });
+                }
+                catch {
+                    /* skip */
+                }
+                try {
+                    (0, fsProtocol_1.purgeStaleExplorerStaging)();
+                }
+                catch {
+                    /* skip */
+                }
+            }
+        }
+        if (st && st.isFile()) {
+            /** One store-only .zip per file selection (same LFS semantics as folder exports). */
+            const baseName = path.basename(localPath);
+            const zipName = `${(0, hfHubPathSanitize_1.sanitizeHubFilename)(baseName)}.zip`;
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), ".forge-hf-filezip-"));
+            const tmpZip = path.join(tmpDir, zipName);
+            try {
+                sendProgress({ phase: "prepare", pct: 5, detail: "copying file snapshot to temp…" });
+                const { mirrorPath } = await (0, exportMirrorCopy_1.copySelectionToMirrorStaging)(localPath, tmpDir, mirrorOpts);
+                sendProgress({ phase: "prepare", pct: 10, detail: "packing file (store-only zip)…" });
+                await writeSingleFileZipStoreOnly(mirrorPath, tmpZip);
+                try {
+                    await (0, exportMirrorCopy_1.removeMirrorStaging)(tmpDir);
+                }
+                catch {
+                    /* temp dir removed in finally */
+                }
+                const remotePath = joinRemotePath(exportBase, zipName);
+                sendProgress({ phase: "upload", pct: 40, detail: remotePath });
+                const out = await uploadFileWithHardening({
+                    repo,
+                    accessToken: token,
+                    hubUrl,
+                    useWebWorkers: false,
+                    useXet: hubUseXet(),
+                    ...(hfFetch ? { fetch: hfFetch } : {}),
+                    file: {
+                        path: remotePath.replace(/\\/g, "/"),
+                        content: await (0, hfHubUploadContent_1.hubContentFromLocalPath)(tmpZip),
+                    },
+                    commitTitle: `Upload ${zipName} (file export)`,
+                }, tmpZip);
+                sendProgress({ phase: "commit", pct: 100, detail: "done" });
+                return {
+                    ok: true,
+                    path: localPath,
+                    repo: resolvedRepoStr,
+                    mode: "zip",
+                    remote_path: remotePath,
+                    commit: out?.commit?.url ?? "",
+                    export_base: exportBase,
+                };
+            }
+            finally {
+                sendProgress({ phase: "cleanup", pct: 100, detail: "removing temp zip" });
+                try {
+                    fs.rmSync(tmpDir, { recursive: true, force: true });
+                }
+                catch {
+                    /* skip */
+                }
+                try {
+                    (0, fsProtocol_1.purgeStaleExplorerStaging)();
+                }
+                catch {
+                    /* skip */
+                }
+            }
+        }
+        if (!st || !st.isDirectory()) {
+            return { ok: false, error: "path is not a file or directory" };
+        }
+        const maxF = maxZipFilesLimit();
+        try {
+            countFilesRecursive(localPath, maxF);
+        }
+        catch (e) {
+            return { ok: false, error: e instanceof Error ? e.message : String(e) };
+        }
+        if (folderMode === "tree") {
+            const treeTmp = fs.mkdtempSync(path.join(os.tmpdir(), ".forge-hf-tree-"));
+            try {
+                sendProgress({ phase: "prepare", pct: 5, detail: "copying folder snapshot for tree upload…" });
+                const { mirrorPath } = await (0, exportMirrorCopy_1.copySelectionToMirrorStaging)(localPath, treeTmp, mirrorOpts);
+                const files = [];
+                const walk = (d, rel) => {
+                    let entries;
+                    try {
+                        entries = fs.readdirSync(d, { withFileTypes: true });
+                    }
+                    catch {
+                        return;
+                    }
+                    for (const ent of entries) {
+                        const abs = path.join(d, ent.name);
+                        const r = rel ? `${rel}/${ent.name}` : ent.name;
+                        if (ent.isSymbolicLink()) {
+                            continue;
+                        }
+                        if (ent.isDirectory()) {
+                            walk(abs, r);
+                        }
+                        else if (ent.isFile()) {
+                            files.push({ abs, rel: r.replace(/\\/g, "/") });
+                        }
+                    }
+                };
+                walk(mirrorPath, "");
+                const total = files.length;
+                if (total === 0) {
+                    return { ok: false, error: HF_MIRROR_NO_FILES_MSG };
+                }
+                const batchSize = treeBatchSize();
+                for (let i = 0; i < files.length; i += batchSize) {
+                    const batch = files.slice(i, i + batchSize);
+                    const done = Math.min(i + batch.length, total);
+                    const pct = Math.round((100 * done) / total);
+                    sendProgress({
+                        phase: "upload",
+                        pct: Math.min(99, Math.max(5, pct)),
+                        detail: `${done}/${total} (batch ${Math.floor(i / batchSize) + 1})`,
+                    });
+                    /** Sequential loads avoid parallel huge buffers and Hub client races on tree batches. */
+                    const loadBatchContents = async () => {
+                        const out = [];
+                        for (const { abs } of batch) {
+                            out.push(await (0, hfHubUploadContent_1.hubContentFromLocalPath)(abs));
+                        }
+                        return out;
+                    };
+                    const hubFilesBase = {
+                        repo,
+                        accessToken: token,
+                        hubUrl,
+                        useWebWorkers: false,
+                        useXet: hubUseXet(),
+                        ...(hfFetch ? { fetch: hfFetch } : {}),
+                        maxFolderDepth: 64,
+                    };
+                    const contents = await loadBatchContents();
+                    const treeCommitTitle = `Upload folder files ${i + 1}–${done} of ${total}`;
+                    try {
+                        await uploadFilesWithHardening({
+                            ...hubFilesBase,
+                            files: batch.map(({ rel }, j) => ({
+                                path: joinRemotePath(exportBase, (0, hfHubPathSanitize_1.sanitizeHubRelativePath)(rel)).replace(/\\/g, "/"),
+                                content: contents[j],
+                            })),
+                            commitTitle: treeCommitTitle,
+                        });
+                    }
+                    catch (e) {
+                        /** Same class of Blob / Hub client TypeErrors as zip uploads — one full re-read of the batch often succeeds. */
+                        if (!isHubBlobOrContentTypeError(e))
+                            throw e;
+                        await yieldEventLoop();
+                        await new Promise((r) => setTimeout(r, 250));
+                        const contents2 = await loadBatchContents();
+                        await uploadFilesWithHardening({
+                            ...hubFilesBase,
+                            files: batch.map(({ rel }, j) => ({
+                                path: joinRemotePath(exportBase, (0, hfHubPathSanitize_1.sanitizeHubRelativePath)(rel)).replace(/\\/g, "/"),
+                                content: contents2[j],
+                            })),
+                            commitTitle: `${treeCommitTitle} (blob retry)`,
+                        });
+                    }
+                    if (delayMs > 0 && i + batchSize < files.length) {
+                        await new Promise((r) => setTimeout(r, delayMs));
+                    }
+                }
+                sendProgress({ phase: "commit", pct: 100, detail: "done" });
+                return {
+                    ok: true,
+                    path: localPath,
+                    repo: resolvedRepoStr,
+                    mode: "tree",
+                    files: total,
+                    export_base: exportBase,
+                };
+            }
+            finally {
+                sendProgress({ phase: "cleanup", pct: 100, detail: "removing tree upload staging" });
+                try {
+                    fs.rmSync(treeTmp, { recursive: true, force: true });
+                }
+                catch {
+                    /* skip */
+                }
+                try {
+                    (0, fsProtocol_1.purgeStaleExplorerStaging)();
+                }
+                catch {
+                    /* skip */
+                }
+            }
+        }
+        /** Default: single store-only zip (minimal CPU; Hub uses LFS for large blobs; Xet never used). */
+        const folderName = path.basename(localPath) || "folder";
+        const zipName = `${(0, hfHubPathSanitize_1.sanitizeHubFilename)(folderName)}.zip`;
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), ".forge-hf-zip-"));
+        const tmpZip = path.join(tmpDir, zipName);
+        try {
+            sendProgress({ phase: "prepare", pct: 8, detail: "copying folder snapshot to temp…" });
+            const { mirrorPath } = await (0, exportMirrorCopy_1.copySelectionToMirrorStaging)(localPath, tmpDir, mirrorOpts);
+            if ((0, exportMirrorCopy_1.countRegularFilesRecursive)(mirrorPath) === 0) {
+                return { ok: false, error: HF_MIRROR_NO_FILES_MSG };
+            }
+            sendProgress({ phase: "prepare", pct: 15, detail: "zipping folder (store-only, low CPU)…" });
+            await writeDirectoryZipStoreOnly(mirrorPath, tmpZip);
+            try {
+                await (0, exportMirrorCopy_1.removeMirrorStaging)(tmpDir);
+            }
+            catch {
+                /* temp dir removed in finally */
+            }
+            const remotePath = joinRemotePath(exportBase, zipName);
+            sendProgress({ phase: "upload", pct: 40, detail: remotePath });
+            const out = await uploadFileWithHardening({
+                repo,
+                accessToken: token,
+                hubUrl,
+                useWebWorkers: false,
+                useXet: hubUseXet(),
+                ...(hfFetch ? { fetch: hfFetch } : {}),
+                file: {
+                    path: remotePath.replace(/\\/g, "/"),
+                    content: await (0, hfHubUploadContent_1.hubContentFromLocalPath)(tmpZip),
+                },
+                commitTitle: `Upload ${zipName} (folder export)`,
+            }, tmpZip);
+            sendProgress({ phase: "commit", pct: 100, detail: "done" });
+            return {
+                ok: true,
+                path: localPath,
+                repo: resolvedRepoStr,
+                mode: "zip",
+                remote_path: remotePath,
+                commit: out?.commit?.url ?? "",
+                export_base: exportBase,
+            };
+        }
+        finally {
+            sendProgress({ phase: "cleanup", pct: 100, detail: "removing temp zip" });
+            try {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch {
+                /* skip */
+            }
+            try {
+                (0, fsProtocol_1.purgeStaleExplorerStaging)();
+            }
+            catch {
+                /* skip */
+            }
+        }
+    }
+    catch (e) {
+        return { ok: false, error: formatHfUploadError(e) };
+    }
+    finally {
+        (0, hfCredentials_1.scrubHfCredentialsInPlace)(cred);
+        (0, fileLockForce_1.restartKilledProcesses)(killedForUnlock, localPath);
+    }
+}
+async function runHfUpload(opts) {
+    const prev = hfUploadSerialGate;
+    let release;
+    hfUploadSerialGate = new Promise((res) => {
+        release = res;
+    });
+    await prev;
+    try {
+        return await withEphemeralHfHubCache(() => runHfUploadCore(opts));
+    }
+    finally {
+        release();
+    }
+}