pushwork 2.0.0-preview.6 → 2.0.0-preview.8

package/dist/utils/mime-types.js

@@ -0,0 +1,247 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnhancedMimeType = getEnhancedMimeType;
+exports.shouldForceAsText = shouldForceAsText;
+exports.isEnhancedTextFile = isEnhancedTextFile;
+const mimeTypes = __importStar(require("mime-types"));
+/**
+ * Custom MIME type definitions for developer files
+ * Based on patchwork-cli's approach
+ */
+const CUSTOM_MIME_TYPES = {
+    // TypeScript files - override the incorrect video/mp2t detection
+    ".ts": "text/typescript",
+    ".tsx": "text/tsx",
+    // Config file formats
+    ".json": "application/json",
+    ".yaml": "text/yaml",
+    ".yml": "text/yaml",
+    ".toml": "application/toml",
+    ".ini": "text/plain",
+    ".conf": "text/plain",
+    ".config": "text/plain",
+    // Vue.js single file components
+    ".vue": "text/vue",
+    // Modern CSS preprocessors
+    ".scss": "text/scss",
+    ".sass": "text/sass",
+    ".less": "text/less",
+    ".styl": "text/stylus",
+    // Modern JavaScript variants
+    ".mjs": "application/javascript",
+    ".cjs": "application/javascript",
+    // React JSX
+    ".jsx": "text/jsx",
+    // Svelte components
+    ".svelte": "text/svelte",
+    // Web assembly
+    ".wasm": "application/wasm",
+    // Other common dev files
+    ".d.ts": "text/typescript",
+    ".map": "application/json", // Source maps
+    ".env": "text/plain",
+    ".gitignore": "text/plain",
+    ".gitattributes": "text/plain",
+    ".editorconfig": "text/plain",
+    ".prettierrc": "application/json",
+    ".eslintrc": "application/json",
+    ".babelrc": "application/json",
+    // Documentation formats
+    ".mdx": "text/markdown",
+    ".rst": "text/x-rst",
+    // Docker files
+    Dockerfile: "text/plain",
+    ".dockerignore": "text/plain",
+    // Package manager files
+    "package.json": "application/json",
+    "package-lock.json": "application/json",
+    "yarn.lock": "text/plain",
+    "pnpm-lock.yaml": "text/yaml",
+    "composer.json": "application/json",
+    Pipfile: "text/plain",
+    "requirements.txt": "text/plain",
+    // Build tool configs
+    "webpack.config.js": "application/javascript",
+    "vite.config.js": "application/javascript",
+    "rollup.config.js": "application/javascript",
+    "tsconfig.json": "application/json",
+    "jsconfig.json": "application/json",
+};
+/**
+ * File extensions that should always be treated as text
+ * regardless of MIME type detection
+ */
+const FORCE_TEXT_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".jsx",
+    ".vue",
+    ".svelte",
+    ".scss",
+    ".sass",
+    ".less",
+    ".styl",
+    ".env",
+    ".gitignore",
+    ".gitattributes",
+    ".editorconfig",
+    ".d.ts",
+    ".map",
+    ".mdx",
+    ".rst",
+    ".toml",
+    ".ini",
+    ".conf",
+    ".config",
+    ".lock",
+]);
+/**
+ * Get enhanced MIME type for file with custom dev file support
+ */
+function getEnhancedMimeType(filePath) {
+    const normalized = normalizePathSeparators(filePath);
+    const filename = normalized.split("/").pop() || "";
+    const extension = getFileExtension(normalized);
+    // Check custom definitions first (by extension)
+    if (extension && CUSTOM_MIME_TYPES[extension]) {
+        return CUSTOM_MIME_TYPES[extension];
+    }
+    // Check custom definitions by full filename
+    if (CUSTOM_MIME_TYPES[filename]) {
+        return CUSTOM_MIME_TYPES[filename];
+    }
+    // Fall back to standard mime-types library
+    const standardMime = mimeTypes.lookup(normalized);
+    if (standardMime) {
+        return standardMime;
+    }
+    // Final fallback
+    return "application/octet-stream";
+}
+/**
+ * Check if file extension should be forced to text type
+ */
+function shouldForceAsText(filePath) {
+    const extension = getFileExtension(filePath);
+    return extension ? FORCE_TEXT_EXTENSIONS.has(extension) : false;
+}
+/**
+ * Get file extension including the dot (internal helper)
+ */
+function getFileExtension(filePath) {
+    const match = filePath.match(/\.[^.]*$/);
+    return match ? match[0].toLowerCase() : "";
+}
+/**
+ * Normalize path separators to forward slashes for cross-platform consistency
+ */
+function normalizePathSeparators(p) {
+    return p.replace(/\\/g, "/");
+}
+/**
+ * Enhanced text file detection with developer file support
+ */
+async function isEnhancedTextFile(filePath) {
+    // Force certain extensions to be treated as text
+    if (shouldForceAsText(filePath)) {
+        return true;
+    }
+    // Check MIME type
+    const mimeType = getEnhancedMimeType(filePath);
+    if (isTextMimeType(mimeType)) {
+        return true;
+    }
+    // If it's a known binary type (but not the generic fallback), don't fall back to content detection
+    if (isBinaryMimeType(mimeType) && mimeType !== "application/octet-stream") {
+        return false;
+    }
+    // For generic octet-stream or unknown types, use content-based detection
+    return isTextByContent(filePath);
+}
+/**
+ * Check if MIME type indicates text content
+ */
+function isTextMimeType(mimeType) {
+    return (mimeType.startsWith("text/") ||
+        mimeType === "application/json" ||
+        mimeType === "application/xml" ||
+        mimeType === "application/javascript" ||
+        mimeType === "application/typescript" ||
+        mimeType === "application/toml" ||
+        mimeType.includes("javascript") ||
+        mimeType.includes("typescript") ||
+        mimeType.includes("json") ||
+        mimeType.includes("xml"));
+}
+/**
+ * Check if MIME type indicates binary content
+ */
+function isBinaryMimeType(mimeType) {
+    return (mimeType.startsWith("image/") ||
+        mimeType.startsWith("video/") ||
+        mimeType.startsWith("audio/") ||
+        mimeType.startsWith("font/") ||
+        mimeType === "application/zip" ||
+        mimeType === "application/pdf" ||
+        mimeType === "application/octet-stream" ||
+        mimeType === "application/wasm" ||
+        mimeType.includes("binary"));
+}
+/**
+ * Content-based text detection (fallback method)
+ */
+async function isTextByContent(filePath) {
+    try {
+        const fs = await Promise.resolve().then(() => __importStar(require("fs/promises")));
+        // Sample first 8KB to detect binary content
+        const handle = await fs.open(filePath, "r");
+        const stats = await handle.stat();
+        const sampleSize = Math.min(8192, stats.size);
+        if (sampleSize === 0) {
+            await handle.close();
+            return true; // Empty file is text
+        }
+        const buffer = Buffer.alloc(sampleSize);
+        await handle.read(buffer, 0, sampleSize, 0);
+        await handle.close();
+        // Check for null bytes which indicate binary content
+        return !buffer.includes(0);
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=mime-types.js.map

package/dist/utils/mime-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mime-types.js","sourceRoot":"","sources":["../../src/utils/mime-types.ts"],"names":[],"mappings":"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"}

package/dist/utils/network-sync.d.ts

@@ -0,0 +1,30 @@
+import { DocHandle, StorageId, Repo, AutomergeUrl } from "@automerge/automerge-repo";
+/**
+ * Wait for bidirectional sync to stabilize.
+ * This function waits until document heads stop changing, indicating that
+ * both outgoing and incoming sync has completed.
+ *
+ * @param repo - The Automerge repository
+ * @param rootDirectoryUrl - The root directory URL to start traversal from
+ * @param options - Configuration options
+ */
+export declare function waitForBidirectionalSync(repo: Repo, rootDirectoryUrl: AutomergeUrl | undefined, options?: {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    stableChecksRequired?: number;
+    handles?: DocHandle<unknown>[];
+}): Promise<void>;
+/**
+ * Result of waitForSync — lists which handles failed to sync.
+ */
+export interface SyncWaitResult {
+    failed: DocHandle<unknown>[];
+}
+/**
+ * Wait for documents to sync to the remote server.
+ * Processes handles in batches to avoid flooding the server.
+ * Returns a result with any failed handles instead of throwing,
+ * so callers can attempt recovery (e.g. recreating documents).
+ */
+export declare function waitForSync(handlesToWaitOn: DocHandle<unknown>[], syncServerStorageId?: StorageId, timeoutMs?: number): Promise<SyncWaitResult>;
+//# sourceMappingURL=network-sync.d.ts.map

package/dist/utils/network-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-sync.d.ts","sourceRoot":"","sources":["../../src/utils/network-sync.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,SAAS,EACT,IAAI,EACJ,YAAY,EACb,MAAM,2BAA2B,CAAC;AAWnC;;;;;;;;GAQG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,IAAI,EACV,gBAAgB,EAAE,YAAY,GAAG,SAAS,EAC1C,OAAO,GAAE;IACP,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,OAAO,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC;CAC3B,GACL,OAAO,CAAC,IAAI,CAAC,CAiFf;AA2FD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC;CAC9B;AAuED;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,eAAe,EAAE,SAAS,CAAC,OAAO,CAAC,EAAE,EACrC,mBAAmB,CAAC,EAAE,SAAS,EAC/B,SAAS,GAAE,MAAc,GACxB,OAAO,CAAC,cAAc,CAAC,CAiFzB"}

package/dist/utils/network-sync.js

@@ -0,0 +1,391 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForBidirectionalSync = waitForBidirectionalSync;
+exports.waitForSync = waitForSync;
+const A = __importStar(require("@automerge/automerge"));
+const output_1 = require("./output");
+const directory_1 = require("./directory");
+const isDebug = !!process.env.DEBUG;
+function debug(...args) {
+    if (isDebug)
+        console.error("[pushwork:sync]", ...args);
+}
+/**
+ * Wait for bidirectional sync to stabilize.
+ * This function waits until document heads stop changing, indicating that
+ * both outgoing and incoming sync has completed.
+ *
+ * @param repo - The Automerge repository
+ * @param rootDirectoryUrl - The root directory URL to start traversal from
+ * @param options - Configuration options
+ */
+async function waitForBidirectionalSync(repo, rootDirectoryUrl, options = {}) {
+    const { timeoutMs = 10000, pollIntervalMs = 100, stableChecksRequired = 3, handles, } = options;
+    if (!rootDirectoryUrl) {
+        return;
+    }
+    const startTime = Date.now();
+    let lastSeenHeads = new Map();
+    let stableCount = 0;
+    let pollCount = 0;
+    let dynamicTimeoutMs = timeoutMs;
+    debug(`waitForBidirectionalSync: starting (timeout=${timeoutMs}ms, stableChecks=${stableChecksRequired}${handles ? `, tracking ${handles.length} handles` : ', full tree scan'})`);
+    while (Date.now() - startTime < dynamicTimeoutMs) {
+        pollCount++;
+        // Get current heads: use provided handles if available, otherwise full tree scan
+        const currentHeads = handles
+            ? getHandleHeads(handles)
+            : await getAllDocumentHeads(repo, rootDirectoryUrl);
+        // After first scan: scale timeout to tree size and reset the clock.
+        // The first scan is just establishing a baseline — its duration
+        // shouldn't count against the stability-wait timeout.
+        if (pollCount === 1) {
+            const scanDuration = Date.now() - startTime;
+            dynamicTimeoutMs = Math.max(timeoutMs, 5000 + currentHeads.size * 50) + scanDuration;
+            debug(`waitForBidirectionalSync: first scan took ${scanDuration}ms, timeout now ${dynamicTimeoutMs}ms for ${currentHeads.size} docs`);
+        }
+        // Check if heads are stable (no changes since last check)
+        const isStable = headsMapEqual(lastSeenHeads, currentHeads);
+        if (isStable) {
+            stableCount++;
+            debug(`waitForBidirectionalSync: stable check ${stableCount}/${stableChecksRequired} (${currentHeads.size} docs, poll #${pollCount})`);
+            if (stableCount >= stableChecksRequired) {
+                const elapsed = Date.now() - startTime;
+                debug(`waitForBidirectionalSync: converged in ${elapsed}ms after ${pollCount} polls (${currentHeads.size} docs)`);
+                output_1.out.taskLine(`Bidirectional sync converged (${currentHeads.size} docs, ${elapsed}ms)`);
+                return; // Converged!
+            }
+        }
+        else {
+            // Find which docs changed
+            if (lastSeenHeads.size > 0) {
+                const changedDocs = [];
+                for (const [url, heads] of currentHeads) {
+                    if (lastSeenHeads.get(url) !== heads) {
+                        changedDocs.push(url);
+                    }
+                }
+                const newDocs = currentHeads.size - lastSeenHeads.size;
+                if (newDocs > 0) {
+                    debug(`waitForBidirectionalSync: ${newDocs} new docs discovered, ${changedDocs.length} docs changed heads (poll #${pollCount})`);
+                }
+                else if (changedDocs.length > 0) {
+                    debug(`waitForBidirectionalSync: ${changedDocs.length} docs changed heads: ${changedDocs.slice(0, 5).join(", ")}${changedDocs.length > 5 ? ` ...and ${changedDocs.length - 5} more` : ""} (poll #${pollCount})`);
+                }
+            }
+            else {
+                debug(`waitForBidirectionalSync: initial scan found ${currentHeads.size} docs (poll #${pollCount})`);
+            }
+            if (stableCount > 0) {
+                debug(`waitForBidirectionalSync: heads changed after ${stableCount} stable checks, resetting`);
+            }
+            stableCount = 0;
+            lastSeenHeads = currentHeads;
+        }
+        await new Promise((r) => setTimeout(r, pollIntervalMs));
+    }
+    // Timeout - but don't throw, just log a warning
+    // The sync may still work, we just couldn't confirm stability
+    const elapsed = Date.now() - startTime;
+    debug(`waitForBidirectionalSync: timed out after ${elapsed}ms (${pollCount} polls, ${lastSeenHeads.size} docs tracked, reached ${stableCount}/${stableChecksRequired} stable checks)`);
+    output_1.out.taskLine(`Bidirectional sync timed out after ${(elapsed / 1000).toFixed(1)}s - document heads were still changing after ${pollCount} checks across ${lastSeenHeads.size} docs (reached ${stableCount}/${stableChecksRequired} stability checks). This may mean another peer is actively editing, or the sync server is slow to relay changes. The sync will continue but some remote changes may not be reflected yet.`, true);
+}
+/**
+ * Get heads from a pre-collected set of handles (cheap, synchronous reads).
+ * Used for post-push stabilization where we already know which documents changed.
+ */
+function getHandleHeads(handles) {
+    const heads = new Map();
+    for (const handle of handles) {
+        heads.set((0, directory_1.getPlainUrl)(handle.url), JSON.stringify(handle.heads()));
+    }
+    return heads;
+}
+/**
+ * Get all document heads in the directory hierarchy.
+ * Returns a map of document URL -> serialized heads.
+ * Uses plain URLs (without heads) to ensure we see current document state.
+ */
+async function getAllDocumentHeads(repo, rootDirectoryUrl) {
+    const heads = new Map();
+    // Pass URL as-is; collectHeadsRecursive will strip heads
+    await collectHeadsRecursive(repo, rootDirectoryUrl, heads);
+    return heads;
+}
+/**
+ * Recursively collect document heads from the directory hierarchy.
+ * Uses getPlainUrl to strip heads and always see the CURRENT state of documents.
+ */
+async function collectHeadsRecursive(repo, directoryUrl, heads) {
+    try {
+        const plainUrl = (0, directory_1.getPlainUrl)(directoryUrl);
+        const handle = await repo.find(plainUrl);
+        const doc = await handle.doc();
+        // Record this directory's heads (use plain URL as key for consistency)
+        heads.set(plainUrl, JSON.stringify(handle.heads()));
+        if (!doc || !doc.docs) {
+            return;
+        }
+        // Process all entries in the directory concurrently
+        await Promise.all(doc.docs.map(async (entry) => {
+            if (entry.type === "folder") {
+                // Recurse into subdirectory (entry.url may have stale heads)
+                await collectHeadsRecursive(repo, entry.url, heads);
+            }
+            else if (entry.type === "file") {
+                // Get file document heads (strip heads from entry.url)
+                try {
+                    const fileUrl = (0, directory_1.getPlainUrl)(entry.url);
+                    const fileHandle = await repo.find(fileUrl);
+                    heads.set(fileUrl, JSON.stringify(fileHandle.heads()));
+                }
+                catch {
+                    // File document may not exist yet
+                }
+            }
+        }));
+    }
+    catch {
+        // Directory may not exist yet
+    }
+}
+/**
+ * Compare two heads maps for equality.
+ */
+function headsMapEqual(a, b) {
+    if (a.size !== b.size) {
+        return false;
+    }
+    for (const [key, value] of a) {
+        if (b.get(key) !== value) {
+            return false;
+        }
+    }
+    return true;
+}
+/** Maximum documents to sync concurrently to avoid flooding the server */
+const SYNC_BATCH_SIZE = 10;
+/**
+ * Wait for a single document handle to sync to the server.
+ * Resolves with the handle on success, rejects with the handle on timeout.
+ */
+function waitForHandleSync(handle, syncServerStorageId, timeoutMs, startTime) {
+    return new Promise((resolve, reject) => {
+        let pollInterval;
+        const cleanup = () => {
+            clearTimeout(timeout);
+            clearInterval(pollInterval);
+            handle.off("remote-heads", onRemoteHeads);
+        };
+        const onConverged = () => {
+            debug(`waitForSync: ${handle.url}... converged in ${Date.now() - startTime}ms`);
+            cleanup();
+            resolve(handle);
+        };
+        const timeout = setTimeout(() => {
+            debug(`waitForSync: ${handle.url}... timed out after ${timeoutMs}ms`);
+            cleanup();
+            reject(handle);
+        }, timeoutMs);
+        const isConverged = () => {
+            const localHeads = handle.heads();
+            const info = handle.getSyncInfo(syncServerStorageId);
+            return A.equals(localHeads, info?.lastHeads);
+        };
+        const onRemoteHeads = ({ storageId, }) => {
+            if (storageId === syncServerStorageId && isConverged()) {
+                onConverged();
+            }
+        };
+        // Initial check
+        if (isConverged()) {
+            cleanup();
+            resolve(handle);
+            return;
+        }
+        // Start polling and event listening
+        pollInterval = setInterval(() => {
+            if (isConverged()) {
+                onConverged();
+            }
+        }, 100);
+        handle.on("remote-heads", onRemoteHeads);
+    });
+}
+/**
+ * Wait for documents to sync to the remote server.
+ * Processes handles in batches to avoid flooding the server.
+ * Returns a result with any failed handles instead of throwing,
+ * so callers can attempt recovery (e.g. recreating documents).
+ */
+async function waitForSync(handlesToWaitOn, syncServerStorageId, timeoutMs = 60000) {
+    const startTime = Date.now();
+    if (handlesToWaitOn.length === 0) {
+        debug("waitForSync: no documents to sync");
+        return { failed: [] };
+    }
+    // When no StorageId is available (Subduction mode), use head-stability
+    // polling. The SubductionSource handles sync internally — we just wait
+    // for each handle's heads to stop changing.
+    if (!syncServerStorageId) {
+        debug(`waitForSync: no storage ID, using head-stability polling for ${handlesToWaitOn.length} documents`);
+        output_1.out.taskLine(`Waiting for ${handlesToWaitOn.length} documents to sync`);
+        return waitForSyncViaHeadStability(handlesToWaitOn, timeoutMs, startTime);
+    }
+    debug(`waitForSync: waiting for ${handlesToWaitOn.length} documents (timeout=${timeoutMs}ms, batchSize=${SYNC_BATCH_SIZE})`);
+    // Separate already-synced from needs-sync
+    const needsSync = [];
+    let alreadySynced = 0;
+    for (const handle of handlesToWaitOn) {
+        const heads = handle.heads();
+        const syncInfo = handle.getSyncInfo(syncServerStorageId);
+        const remoteHeads = syncInfo?.lastHeads;
+        if (A.equals(heads, remoteHeads)) {
+            alreadySynced++;
+            debug(`waitForSync: ${handle.url}... already synced`);
+        }
+        else {
+            debug(`waitForSync: ${handle.url}... needs sync (remoteHeads=${remoteHeads ? 'present' : 'missing'})`);
+            needsSync.push(handle);
+        }
+    }
+    if (needsSync.length > 0) {
+        debug(`waitForSync: ${alreadySynced} already synced, ${needsSync.length} need sync`);
+        output_1.out.taskLine(`Uploading: ${alreadySynced}/${handlesToWaitOn.length} already synced, waiting for ${needsSync.length} more`);
+    }
+    else {
+        debug(`waitForSync: all ${handlesToWaitOn.length} already synced`);
+        return { failed: [] };
+    }
+    // Process in batches to avoid flooding the server
+    const failed = [];
+    let synced = alreadySynced;
+    for (let i = 0; i < needsSync.length; i += SYNC_BATCH_SIZE) {
+        const batch = needsSync.slice(i, i + SYNC_BATCH_SIZE);
+        const batchNum = Math.floor(i / SYNC_BATCH_SIZE) + 1;
+        const totalBatches = Math.ceil(needsSync.length / SYNC_BATCH_SIZE);
+        if (totalBatches > 1) {
+            debug(`waitForSync: batch ${batchNum}/${totalBatches} (${batch.length} docs)`);
+            output_1.out.update(`Uploading batch ${batchNum}/${totalBatches} (${synced}/${handlesToWaitOn.length} done)`);
+        }
+        const results = await Promise.allSettled(batch.map(handle => waitForHandleSync(handle, syncServerStorageId, timeoutMs, startTime)));
+        for (const result of results) {
+            if (result.status === "rejected") {
+                failed.push(result.reason);
+            }
+            else {
+                synced++;
+            }
+        }
+    }
+    const elapsed = Date.now() - startTime;
+    if (failed.length > 0) {
+        debug(`waitForSync: ${failed.length} documents failed after ${elapsed}ms`);
+        output_1.out.taskLine(`Upload: ${synced} synced, ${failed.length} failed after ${(elapsed / 1000).toFixed(1)}s`, true);
+    }
+    else {
+        debug(`waitForSync: all ${handlesToWaitOn.length} documents synced in ${elapsed}ms (${alreadySynced} were already synced)`);
+        output_1.out.taskLine(`All ${handlesToWaitOn.length} documents uploaded to server (${(elapsed / 1000).toFixed(1)}s)`);
+    }
+    return { failed };
+}
+/**
+ * Wait for sync by polling head stability (Subduction mode).
+ * Each handle's heads are polled until they remain unchanged for
+ * several consecutive checks, indicating the SubductionSource has
+ * finished syncing.
+ */
+async function waitForSyncViaHeadStability(handles, timeoutMs, startTime) {
+    const failed = [];
+    let synced = 0;
+    // Process in batches
+    for (let i = 0; i < handles.length; i += SYNC_BATCH_SIZE) {
+        const batch = handles.slice(i, i + SYNC_BATCH_SIZE);
+        const results = await Promise.allSettled(batch.map(handle => waitForHandleHeadStability(handle, timeoutMs, startTime)));
+        for (const result of results) {
+            if (result.status === "rejected") {
+                failed.push(result.reason);
+            }
+            else {
+                synced++;
+            }
+        }
+    }
+    const elapsed = Date.now() - startTime;
+    if (failed.length > 0) {
+        debug(`waitForSync(heads): ${failed.length} documents failed after ${elapsed}ms`);
+        output_1.out.taskLine(`Sync: ${synced} synced, ${failed.length} timed out after ${(elapsed / 1000).toFixed(1)}s`, true);
+    }
+    else {
+        debug(`waitForSync(heads): all ${handles.length} documents synced in ${elapsed}ms`);
+        output_1.out.taskLine(`All ${handles.length} documents synced (${(elapsed / 1000).toFixed(1)}s)`);
+    }
+    return { failed };
+}
+/**
+ * Wait for a single handle's heads to stabilize.
+ * Polls heads at 100ms intervals; resolves after 3 consecutive stable
+ * checks, rejects on timeout.
+ */
+function waitForHandleHeadStability(handle, timeoutMs, startTime) {
+    return new Promise((resolve, reject) => {
+        let lastHeads = JSON.stringify(handle.heads());
+        let stableCount = 0;
+        const stableRequired = 3;
+        const pollInterval = setInterval(() => {
+            const currentHeads = JSON.stringify(handle.heads());
+            if (currentHeads === lastHeads) {
+                stableCount++;
+                if (stableCount >= stableRequired) {
+                    clearInterval(pollInterval);
+                    clearTimeout(timeout);
+                    debug(`waitForSync(heads): ${handle.url}... converged in ${Date.now() - startTime}ms`);
+                    resolve(handle);
+                }
+            }
+            else {
+                stableCount = 0;
+                lastHeads = currentHeads;
+            }
+        }, 100);
+        const timeout = setTimeout(() => {
+            clearInterval(pollInterval);
+            debug(`waitForSync(heads): ${handle.url}... timed out after ${timeoutMs}ms`);
+            reject(handle);
+        }, timeoutMs);
+    });
+}
+//# sourceMappingURL=network-sync.js.map