code_gallery

Web News Blog Press Pricing

Learn

Training

Profiles

Executive

Templates

Animation VFX

Code

Code Gallery Designer

v6.09

After Effects

Check Ref Download

Raul 14/04/2026

Tags
references download assets plates renders

Check Ref Download

Raul

Action v2

14/04/2026

After Effects

Pseudo-Code

Parameters

Talk with TD Support

Import to my Pipeline

Code

// ============================================================
// CHECKER: Missing Asset References - After Effects
// ============================================================
//
// EXECUTION CONTEXT (injected by main.js via new Function):
//   - print_to_console(msg)         → log to the Checkers console panel
//   - __checker_callback__(result)   → call with true (pass) or "error string" (fail)
//   - window.csInterface             → CEP bridge to AE (evalScript)
//   - window.pipelineAPI             → platform GraphQL API
//   - window.websocket               → Kraken Manager WebSocket
//
// HOW IT WORKS:
//   Step 1 — ExtendScript scans the AE project for broken footage items
//            (PlaceholderSource, FileSource with no file, or file not on disk)
//   Step 2 — For each broken item, determine the search key:
//            · Image sequence (filename matches /\.\d{4}\.\w+$/):
//              take the parent folder name and search as "folderName.zip"
//            · Single file (mov, mp4, exr, psd, etc.):
//              search by the full basename with extension
//            Then call fileSearch(fileName, token) on the platform API.
//   Fix    — For each resolved item:
//            · ZIP (image sequence): send download_and_extract order to Kraken Manager,
//              poll disk until the sequence folder appears, then relink using the
//              original fsName (which matches the post-extract path exactly).
//            · Single file: send download_file_direct order, poll disk, relink.
//
// ============================================================

// ============================================================
// STEP 1 — Ask AE for all broken footage items
// ============================================================

/**
 * Scan the After Effects project for footage items with broken or missing file references.
 *
 * Three failure cases are detected:
 *   - "placeholder"      → item is a PlaceholderSource (AE internal stand-in, no real file)
 *   - "no_file_ref"      → item has a FileSource but the File object is null or has no fsName
 *   - "file_not_on_disk" → item has a valid FileSource path but the file does not exist on disk
 *
 * The ExtendScript code is built as an array of strings joined with newlines
 * because template literals are not safe in the outer CEP context when building
 * code that will be sent to the AE ExtendScript engine.
 *
 * Data is returned from ExtendScript as a flat string using custom delimiters
 * (<<<REC>>> between records, <<<SEP>>> between fields) to avoid conflicts
 * with characters that could appear in file paths.
 *
 * @returns {Promise<Array<{ index: number, filename: string, fsName: string, reason: string }>>}
 *   index    - 1-based position of the item in app.project.items
 *   filename - name of the file (e.g. "char_hero.exr" or "frame.0001.exr")
 *   fsName   - full absolute path as AE knows it (may not exist on disk)
 *   reason   - one of "placeholder", "no_file_ref", "file_not_on_disk"
 */
function getBrokenFootageItems() {

var extendScriptCode = lines.join("\n");

return new Promise(function(resolve) {
        window.csInterface.evalScript(extendScriptCode, function(result) {
            var clean = (result || "").replace(/^"|"$/g, "").trim();

if (!clean || clean.indexOf("JSERROR:") === 0) {
                print_to_console("[Check Refs Missing] ExtendScript error: " + clean);
                resolve([]);
                return;
            }

if (clean === "") {
                resolve([]);
                return;
            }

try {
                var items   = [];
                var records = clean.split("<<<REC>>>");

for (var i = 0; i < records.length; i++) {
                    if (!records[i]) continue;
                    var fields = records[i].split("<<<SEP>>>");
                    if (fields.length < 4) continue;

var decodedName = fields[1];
                    try { decodedName = decodeURIComponent(fields[1]); } catch(e) {}

var decodedFsName = fields[2];
                    try { decodedFsName = decodeURIComponent(fields[2]); } catch(e) {}

items.push({
                        index:    parseInt(fields[0], 10),
                        filename: decodedName,
                        fsName:   decodedFsName,
                        reason:   fields[3]
                    });
                }

resolve(items);

} catch(e) {
                print_to_console("[Check Refs Missing] Parse error: " + e.toString());
                resolve([]);
            }
        });
    });
}

// ============================================================
// STEP 2 — Determine search key and resolve via fileSearch
// ============================================================

/**
 * Detect whether a filename is part of an image sequence.
 *
 * An image sequence frame follows the pattern: name.NNNN.ext
 * where NNNN is exactly 4 digits. This is the standard AE / pipeline
 * convention produced by "archivo.%04d.exr" render outputs.
 *
 * Examples:
 *   "frame.0001.exr"   → true
 *   "VFX_shot.1001.png" → true
 *   "hero_char.psd"    → false
 *   "output.mov"       → false
 *
 * @param {string} filename - Just the filename, no path
 * @returns {boolean}
 */
function isImageSequence(filename) {
    return /\.\d{4}\.[^.]+$/.test(filename);
}

/**
 * Given the fsName of an image sequence frame, return the name of the
 * parent folder (which is the folder that gets zipped on upload).
 *
 * Example:
 *   fsName: "D:/Projects/.../render/r037/VFX_shot_Multi-Layer/VFX_shot.0001.exr"
 *   → parentFolder: "VFX_shot_Multi-Layer"
 *   → searchKey:    "VFX_shot_Multi-Layer.zip"
 *
 * @param {string} fsName - Full absolute path of the frame file
 * @returns {string} The zip filename to search for (e.g. "VFX_shot_Multi-Layer.zip")
 */
function getZipSearchKey(fsName) {
    // Normalize separators to forward slashes for consistent splitting
    var normalized = fsName.replace(/\\/g, "/");
    var parts = normalized.split("/");

// The frame file is the last part; its parent folder is the second-to-last
    // parts[-1] = "VFX_shot.0001.exr"
    // parts[-2] = "VFX_shot_Multi-Layer"  ← this is the folder to zip
    if (parts.length >= 2) {
        var parentFolder = parts[parts.length - 2];
        return parentFolder + ".zip";
    }

// Fallback — should not happen with a valid absolute path
    return null;
}

/**
 * Query the platform using fileSearch(fileName, token) to find whether
 * the given search key (zip name or single-file basename) is registered
 * as a published file.
 *
 * fileSearch returns an array. We take the first result whose fileName
 * matches exactly — this guards against partial-match false positives.
 *
 * Returns null if nothing is found or if the API call fails.
 *
 * @param {string} searchKey - Filename to search (e.g. "VFX_shot_folder.zip" or "hero.psd")
 * @returns {Promise<{ fileLocal, pathToFile, link } | null>}
 */
function searchFileOnPlatform(searchKey) {
    if (!window.pipelineAPI) {
        print_to_console("[Check Refs Missing] pipelineAPI not available");
        return Promise.resolve(null);
    }

var safeKey = searchKey.replace(/"/g, '\\"');

var query = [
        "query {",
        "    fileSearch(fileName: \"" + safeKey + "\", token: \"{token}\") {",
        "        fileName",
        "        fileLocal",
        "        pathToFile",
        "        link",
        "    }",
        "}"
    ].join("\n");

return window.pipelineAPI.query(query)
        .then(function(response) {
            if (!response || !response.fileSearch || response.fileSearch.length === 0) {
                print_to_console("[Check Refs Missing] Not found on platform: " + searchKey);
                return null;
            }

// Find exact filename match (fileSearch may return partial matches)
            var match = null;
            for (var i = 0; i < response.fileSearch.length; i++) {
                if (response.fileSearch[i].fileName === searchKey) {
                    match = response.fileSearch[i];
                    break;
                }
            }

// If no exact match, take the first result as best effort
            if (!match) {
                match = response.fileSearch[0];
            }

print_to_console(
                "[Check Refs Missing] Found on platform: " + searchKey +
                " → fileLocal: " + match.fileLocal
            );

return {
                fileLocal:  match.fileLocal,
                pathToFile: match.pathToFile,
                link:       match.link
            };
        })
        .catch(function(err) {
            print_to_console("[Check Refs Missing] API error for '" + searchKey + "': " + (err.message || err));
            return null;
        });
}

/**
 * Resolve a single broken footage item against the platform.
 *
 * Decision logic:
 *   · If the filename is an image sequence frame (matches .NNNN.ext):
 *       searchKey = parentFolderName + ".zip"
 *       isZip     = true
 *   · Otherwise:
 *       searchKey = filename as-is
 *       isZip     = false
 *
 * The returned object merges the AE item data with the platform response,
 * and adds isZip so that fix_process() knows whether to decompress.
 *
 * @param {Object} item - Broken footage item from getBrokenFootageItems()
 * @returns {Promise<Object>} Enriched item with platform data, or original item with nulls
 */
function resolveItemOnPlatform(item) {
    var searchKey;
    var isZip;

if (isImageSequence(item.filename)) {
        // Image sequence: search by the parent folder zip name
        searchKey = getZipSearchKey(item.fsName);
        isZip     = true;

if (!searchKey) {
            print_to_console("[Check Refs Missing] Could not determine zip key for: " + item.fsName);
            return Promise.resolve(buildUnresolved(item, true));
        }
    } else {
        // Single file: search by the exact filename
        searchKey = item.filename;
        isZip     = false;
    }

print_to_console("[Check Refs Missing] Searching platform for: " + searchKey);

return searchFileOnPlatform(searchKey).then(function(platformData) {
        if (!platformData) {
            return buildUnresolved(item, isZip);
        }
        return {
            index:      item.index,
            filename:   item.filename,
            fsName:     item.fsName,
            reason:     item.reason,
            isZip:      isZip,
            searchKey:  searchKey,
            fileLocal:  platformData.fileLocal,
            pathToFile: platformData.pathToFile,
            link:       platformData.link
        };
    });
}

/**
 * Build an unresolved item object (platform data not found).
 * These items are reported in check_process() but skipped by fix_process().
 *
 * @param {Object} item  - Original broken footage item
 * @param {boolean} isZip - Whether this item was expected to be a zip
 * @returns {Object}
 */
function buildUnresolved(item, isZip) {
    return {
        index:      item.index,
        filename:   item.filename,
        fsName:     item.fsName,
        reason:     item.reason,
        isZip:      isZip,
        searchKey:  null,
        fileLocal:  null,
        pathToFile: null,
        link:       null
    };
}

// ============================================================
// CORE — getMissingAssets
// ============================================================

/**
 * Orchestrate Steps 1 and 2 to produce the full list of broken footage items,
 * each enriched with platform metadata (fileLocal, pathToFile, link, isZip).
 *
 * Flow:
 *   1. getBrokenFootageItems() — scan AE for all broken items
 *   2. For each item, resolveItemOnPlatform() in parallel (Promise.all)
 *   3. Return merged array
 *
 * Items not found on the platform have fileLocal/link set to null.
 * They are included in the result so check_process() can report them,
 * but fix_process() will skip them.
 *
 * @returns {Promise<Array<Object>>}
 */
function getMissingAssets() {
    return getBrokenFootageItems().then(function(brokenItems) {

if (brokenItems.length === 0) {
            return [];
        }

print_to_console("[Check Refs Missing] Found " + brokenItems.length + " broken footage item(s):");
        brokenItems.forEach(function(item) {
            print_to_console(
                "  [" + item.reason + "] " + item.filename +
                (item.fsName ? "  (was: " + item.fsName + ")" : "")
            );
        });

// Resolve all items against the platform in parallel
        var promises = brokenItems.map(function(item) {
            return resolveItemOnPlatform(item);
        });

return Promise.all(promises);
    });
}

// ============================================================
// FIX HELPERS
// ============================================================

/**
 * Send a download order to Kraken Manager over WebSocket.
 *
 * Two order types depending on whether the file is a zip:
 *
 *   download_file_direct  → single file, Kraken downloads to fileLocal
 *   download_and_extract  → zip file, Kraken downloads to fileLocal then
 *                           calls decompress_folder(fileLocal) which moves
 *                           contents up one level and cleans up the zip
 *                           and the temporary extraction folder.
 *
 * For zip items, fileLocal from the platform points to the zip file itself
 * (e.g. ".../render/r037/VFX_shot_folder/VFX_shot_folder.zip"). Kraken
 * Manager downloads it there and decompress_folder handles the rest.
 *
 * @param {Object} item - Resolved missing asset
 * @returns {boolean} true if the WebSocket message was sent
 */
function sendDownloadOrder(item) {
    if (!websocket || websocket.readyState !== WebSocket.OPEN) {
        print_to_console("[Check Refs Missing] WebSocket not connected — cannot send download order for: " + item.filename);
        return false;
    }

if (!item.fileLocal) {
        print_to_console("[Check Refs Missing] No fileLocal for: " + item.filename + " — skipping download");
        return false;
    }

if (!item.link) {
        print_to_console("[Check Refs Missing] No download link for: " + item.filename + " — skipping download");
        return false;
    }

var order = item.isZip ? "download_and_extract" : "download_file_direct";

var message = {
        order:      order,
        dcc:        "after effects",
        target:     "kraken",
        file_link:  item.link,
        file_local: item.fileLocal
    };

try {
        websocket.send(JSON.stringify(message));
        print_to_console(
            "[Check Refs Missing] " + order + " order sent: " +
            item.filename + " → " + item.fileLocal
        );
        return true;
    } catch(e) {
        print_to_console("[Check Refs Missing] Failed to send order for " + item.filename + ": " + e.message);
        return false;
    }
}

/**
 * Poll the filesystem via ExtendScript every intervalMs milliseconds
 * until the file at localPath exists on disk or the timeout is reached.
 *
 * For zip items, localPath is the fsName of the original sequence frame
 * (e.g. ".../render/r037/VFX_shot_folder/frame.0001.exr") — once Kraken
 * finishes decompressing, that file will exist and the poll resolves.
 *
 * For single files, localPath is the fileLocal returned by the platform.
 *
 * @param {string} localPath   - Absolute local path to check for existence
 * @param {number} timeoutMs   - Maximum wait time in ms (default: 60000)
 * @param {number} intervalMs  - Polling interval in ms (default: 5000)
 * @returns {Promise<boolean>} true if the file appeared, false on timeout
 */
function waitForFileOnDisk(localPath, timeoutMs, intervalMs) {
    timeoutMs  = timeoutMs  || 60000;
    intervalMs = intervalMs || 5000;

var safePath = localPath.replace(/\\/g, "\\\\");

var started = Date.now();

return new Promise(function(resolve) {
        function poll() {
            window.csInterface.evalScript(checkScript, function(result) {
                var clean = (result || "").replace(/^"|"$/g, "").trim();

if (clean === "true") {
                    print_to_console("[Check Refs Missing] File found on disk: " + localPath);
                    resolve(true);
                    return;
                }

var elapsed = Date.now() - started;
                if (elapsed >= timeoutMs) {
                    print_to_console("[Check Refs Missing] Timeout waiting for file: " + localPath);
                    resolve(false);
                    return;
                }

print_to_console(
                    "[Check Refs Missing] Waiting for file... (" +
                    Math.round(elapsed / 1000) + "s): " + localPath
                );
                setTimeout(poll, intervalMs);
            });
        }
        poll();
    });
}

/**
 * Relink a broken footage item in the AE project to a new file on disk.
 *
 * Uses item.replace(file) — equivalent to right-clicking a footage item
 * in the AE Project panel and choosing "Replace Footage > File...".
 * All layers using this footage item are updated automatically.
 *
 * For ZIP items: after decompress_folder runs, the original fsName path
 * exists on disk exactly as AE remembered it, so we pass fsName directly.
 * For single files: we pass the fileLocal path returned by the platform.
 *
 * @param {number} itemIndex - 1-based index of the item in app.project.items
 * @param {string} localPath - Absolute path to the file now on disk
 * @returns {Promise<boolean>} true if AE confirmed the relink
 */
function relinkFootageItem(itemIndex, localPath, isSequence) {
    var safePath = localPath.replace(/\\/g, "\\\\");

var lines;

if (isSequence) {
        lines = [
            "(function() {",
            "    try {",
            "        var item = app.project.item(" + itemIndex + ");",
            "        if (!item || !(item instanceof FootageItem)) {",
            "            return 'error:not_footage_item';",
            "        }",
            "        var f = new File('" + safePath + "');",
            "        if (!f.exists) {",
            "            return 'error:file_not_found';",
            "        }",
            "        item.replaceWithSequence(f, false);",
            "        return 'ok';",
            "    } catch(e) {",
            "        return 'error:' + e.toString();",
            "    }",
            "})();"
        ];
    } else {
        lines = [
            "(function() {",
            "    try {",
            "        var item = app.project.item(" + itemIndex + ");",
            "        if (!item || !(item instanceof FootageItem)) {",
            "            return 'error:not_footage_item';",
            "        }",
            "        var f = new File('" + safePath + "');",
            "        if (!f.exists) {",
            "            return 'error:file_not_found';",
            "        }",
            "        item.replace(f);",
            "        return 'ok';",
            "    } catch(e) {",
            "        return 'error:' + e.toString();",
            "    }",
            "})();"
        ];
    }

return new Promise(function(resolve) {
        window.csInterface.evalScript(lines.join("\n"), function(result) {
            var clean = (result || "").replace(/^"|"$/g, "").trim();
            if (clean === "ok") {
                print_to_console("[Check Refs Missing] Relinked successfully: " + localPath);
                resolve(true);
            } else {
                var errorMsg = clean.replace(/^error:/, "").trim();
                var userMsg =
                    "[Check Refs Missing] Could not relink: " + localPath + "\n" +
                    "  Reason: " + errorMsg + "\n" +
                    "  This file may use an unsupported codec or format in After Effects. " +
                    "Please relink it manually via Replace Footage > File.";

print_to_console(userMsg);
                sendToKrakenConsole(userMsg);
                resolve(false);
            }
        });
    });
}

// ============================================================
// KRAKEN CONSOLE HELPER
// ============================================================

/**
 * Send a print_to_console order to Kraken Manager via WebSocket.
 * Mirrors the message in the Kraken web console in addition to the
 * local plugin panel log.
 *
 * @param {string} message - Text to print in the Kraken console
 */
function sendToKrakenConsole(message) {
    if (!websocket || websocket.readyState !== WebSocket.OPEN) {
        print_to_console("[Check Refs Missing] WebSocket not open — cannot send to Kraken console");
        return;
    }
    try {
        websocket.send(JSON.stringify({
            order:   "print_to_console",
            dcc:     "after effects",
            target:  "kraken",
            command: message
        }));
    } catch(e) {
        print_to_console("[Check Refs Missing] Failed to send to Kraken console: " + e.message);
    }
}

// ============================================================
// PROCESS FUNCTIONS
// ============================================================

/**
 * Check for broken footage references in the current AE project.
 *
 * Reports how many broken items were found on the platform (fixable)
 * and how many were not (cannot be auto-fixed).
 * Does not modify the project.
 *
 * @returns {Promise<{ result: boolean, error: string|false }>}
 */
function check_process() {
    return getMissingAssets().then(function(missingItems) {

if (missingItems.length === 0) {
            print_to_console("[Check Refs Missing] All footage references are valid.");
            return { result: true, error: false };
        }

var fixable   = missingItems.filter(function(i) { return i.link !== null; });
        var unfixable = missingItems.filter(function(i) { return i.link === null; });

print_to_console("[Check Refs Missing] Summary:");
        print_to_console("  " + fixable.length + " broken reference(s) found on platform (fixable)");

if (unfixable.length > 0) {
            print_to_console("  " + unfixable.length + " broken reference(s) NOT found on platform:");
            unfixable.forEach(function(i) {
                print_to_console("    - " + i.filename + (i.isZip ? " [searched as: " + (i.searchKey || "unknown.zip") + "]" : ""));
            });
        }

var names = missingItems.map(function(i) { return i.filename || "Unknown"; });
        return {
            result: false,
            error:  "Found " + missingItems.length + " broken reference(s): " + names.join(", ")
        };

}).catch(function(e) {
        return { result: false, error: "Check error: " + e.message };
    });
}

/**
 * Select all broken footage items in the AE Project panel.
 *
 * Clears the current selection and selects only the broken footage items
 * so the artist can see at a glance which references need attention.
 *
 * Always returns result: false so the checker UI does not turn green —
 * selecting items highlights the problem but does not fix it.
 *
 * @returns {Promise<{ result: false, error: string }>}
 */
function select_process() {
    return getBrokenFootageItems().then(function(brokenItems) {

if (brokenItems.length === 0) {
            print_to_console("[Check Refs Missing] No broken items to select.");
            return { result: true, error: false };
        }

var indexList = brokenItems.map(function(i) { return i.index; }).join(",");

return new Promise(function(resolve) {
            window.csInterface.evalScript(lines.join("\n"), function() {
                var names = brokenItems.map(function(i) { return i.filename || "Unknown"; });
                resolve({
                    result: false,
                    error:  "Found " + brokenItems.length + " broken reference(s): " + names.join(", ")
                });
            });
        });

}).catch(function(e) {
        return { result: false, error: "Select error: " + e.message };
    });
}

/**
 * Fix all broken footage references.
 *
 * Flow:
 *   1. getMissingAssets() — get current broken items enriched with platform data
 *   2. Split into fixable (have link + fileLocal) and unfixable
 *   3. Deduplicate by fileLocal — multiple AE items pointing to the same file
 *      (e.g. frames of the same sequence all map to the same zip) share one download
 *   4. For each unique fileLocal:
 *        a. Send download order (download_file_direct or download_and_extract)
 *        b. Poll disk:
 *             · ZIP items: poll for fsName of first item in group
 *               (sequence frame path — appears after decompress_folder finishes)
 *             · Single files: poll for fileLocal
 *        c. Relink each AE item index in the group:
 *             · ZIP items: relink with the item's own fsName
 *             · Single files: relink with fileLocal
 *   5. Report to plugin panel and Kraken console
 *
 * Items are processed sequentially to keep logs readable and avoid
 * flooding the WebSocket with simultaneous download requests.
 *
 * @returns {Promise<boolean>} true if at least one item was fixed
 */
function fix_process() {
    return getMissingAssets().then(function(missingItems) {

if (missingItems.length === 0) {
            print_to_console("[Check Refs Missing] No broken references found — nothing to fix.");
            return true;
        }

var fixable   = missingItems.filter(function(i) { return i.link !== null && i.fileLocal !== null; });
        var unfixable = missingItems.filter(function(i) { return i.link === null || i.fileLocal === null; });

if (unfixable.length > 0) {
            print_to_console("[Check Refs Missing] " + unfixable.length + " item(s) cannot be fixed (not found on platform):");
            unfixable.forEach(function(i) {
                print_to_console("    - " + i.filename +
                    (i.isZip ? " [searched as: " + (i.searchKey || "unknown.zip") + "]" : ""));
            });
        }

if (fixable.length === 0) {
            print_to_console("[Check Refs Missing] No fixable items found.");
            return false;
        }

// ── DEDUPLICATION ────────────────────────────────────────────────
        // Group by fileLocal (the zip path or the single file path).
        // Multiple AE footage items may reference frames of the same sequence,
        // all of which map to the same zip — one download, multiple relinks.
        //
        // For ZIP groups, each item keeps its own fsName for relinking because
        // different footage items may point to different frames or even different
        // subfolders within the same zip.
        //
        // Group structure:
        // {
        //   "O:/.../VFX_folder/VFX_folder.zip": {
        //     representative: <item>,      ← provides link, fileLocal, isZip for download
        //     members: [<item>, <item>]    ← all items to relink after download
        //   }
        // }
        var groups = {};
        fixable.forEach(function(i) {
            var key = i.fileLocal;
            if (!groups[key]) {
                groups[key] = { representative: i, members: [] };
            }
            groups[key].members.push(i);
        });

var uniqueKeys = Object.keys(groups);
        print_to_console(
            "[Check Refs Missing] Fixing " + fixable.length + " item(s) across " +
            uniqueKeys.length + " unique download(s)"
        );

// ── SEQUENTIAL FIX PER GROUP ────────────────────────────────────
        var totalFixed = 0;

function fixNextGroup(gIndex) {
            if (gIndex >= uniqueKeys.length) {
                var summary =
                    "[Check Refs Missing] Fix complete: " +
                    totalFixed + " / " + fixable.length + " item(s) relinked";
                print_to_console(summary);
                sendToKrakenConsole(summary);
                return Promise.resolve(totalFixed > 0);
            }

var fileLocalKey = uniqueKeys[gIndex];
            var group        = groups[fileLocalKey];
            var rep          = group.representative;

print_to_console(
                "[Check Refs Missing] Processing: " + rep.searchKey +
                " (" + group.members.length + " item(s))" +
                (rep.isZip ? " [zip → extract]" : " [direct]")
            );

// Step a: send the appropriate download order
            var sent = sendDownloadOrder(rep);
            if (!sent) {
                return fixNextGroup(gIndex + 1);
            }

// Step b: determine which path to poll for
            // ZIP: poll the fsName of the first member — this is the sequence frame
            //      path that will exist on disk once decompress_folder completes.
            // Single file: poll fileLocal directly.
            var pollPath = rep.isZip ? group.members[0].fsName : rep.fileLocal;

return waitForFileOnDisk(pollPath, 60000, 5000).then(function(appeared) {
                if (!appeared) {
                    print_to_console("[Check Refs Missing] File did not appear: " + pollPath);
                    return fixNextGroup(gIndex + 1);
                }

// Step c: relink each member with its correct path
                function relinkNext(rIndex) {
                    if (rIndex >= group.members.length) {
                        return Promise.resolve();
                    }
                    var member    = group.members[rIndex];
                    // ZIP items: each member knows its own fsName (frame path)
                    // Single files: all members share the same fileLocal
                    var relinkPath = member.isZip ? member.fsName : member.fileLocal;

return relinkFootageItem(member.index, relinkPath, member.isZip).then(function(ok) {
                        if (ok) totalFixed++;
                        return relinkNext(rIndex + 1);
                    });
                    
                }

return relinkNext(0).then(function() {
                    return fixNextGroup(gIndex + 1);
                });
            });
        }

return fixNextGroup(0);

}).catch(function(e) {
        var msg = "[Check Refs Missing] Fix error: " + e.message;
        print_to_console(msg);
        sendToKrakenConsole(msg);
        return false;
    });
}

// ============================================================
// UI FUNCTIONS — do not change
// ============================================================

/**
 * Entry point for the Check operation.
 * Called by the Kraken checker runner in main.js as: check(__checker_callback__)
 *
 * @param {Function} callback - __checker_callback__ injected by main.js
 */
function check(callback) {
    check_process().then(function(r) {
        callback(r.result ? true : r.error);
    }).catch(function(e) {
        callback("Error: " + e.message);
    });
}

/**
 * Entry point for the Select operation.
 * Called by the Kraken checker runner in main.js as: select(__checker_callback__)
 *
 * @param {Function} callback - __checker_callback__ injected by main.js
 */
function select(callback) {
    select_process().then(function(r) {
        callback(r.result ? true : r.error);
    }).catch(function(e) {
        callback("Error: " + e.message);
    });
}

/**
 * Entry point for the Fix operation.
 * Called by the Kraken checker runner in main.js as: fix(__checker_callback__)
 *
 * Uses window.fixCallback directly instead of __checker_callback__ because
 * the fix result is an array [fixResult, checkResult] and __checker_callback__
 * only handles true/string — passing an array would be coerced incorrectly.
 * window.fixCallback is set by main.js and handles the array format correctly.
 *
 * @param {Function} callback - __checker_callback__ injected by main.js (fallback)
 */
function fix(callback) {
    fix_process().then(function(fixResult) {
        var result = [
            fixResult === true ? true : false,
            fixResult === true ? true : "Fix did not complete successfully"
        ];
        if (window.fixCallback) {
            window.fixCallback(result);
        } else {
            callback(result);
        }
    }).catch(function(e) {
        var result = [false, "Error: " + e.message];
        if (window.fixCallback) {
            window.fixCallback(result);
        } else {
            callback(result);
        }
    });
}

Import Action

1. Copy Key

Copy

2. Go to your Action pannel

Go