@tenonhq/sincronia-core 0.0.81 → 0.0.82

package/dist/FileUtils.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeFileForce = exports.writeSNFileForce = exports.writeSNFileIfNotExists = exports.writeBuildFile = exports.summarizeFile = exports.encodedPathsToFilePaths = exports.isValidPath = exports.splitEncodedPaths = exports.getPathsInPath = exports.isDirectory = exports.toAbsolutePath = exports.getFileContextFromPath = exports.getFileContextWithSkipReason = exports.getBuildExt = exports.isUnderPath = exports.appendToPath = exports.pathExists = exports.createDirRecursively = exports.writeSNFileCurry = exports.writeScopeManifest = exports.writeManifestFile = exports.SNFileExists = void 0;
+exports.writeFileForce = exports.writeSNFileForce = exports.writeSNFileIfNotExists = exports.writeBuildFile = exports.summarizeFile = exports.encodedPathsToFilePaths = exports.isValidPath = exports.splitEncodedPaths = exports.getPathsInPath = exports.isDirectory = exports.toAbsolutePath = exports.getFileContextFromPath = exports.getFileContextWithSkipReason = exports.getBuildExt = exports.isUnderPath = exports.appendToPath = exports.pathExists = exports.createDirRecursively = exports.writeSNFileIfDifferent = exports.writeSNFileCurry = exports.writeScopeManifest = exports.writeManifestFile = exports.SNFileExists = void 0;
 exports.writeEnvVar = writeEnvVar;
 exports.writeEnvVars = writeEnvVars;
 const constants_1 = require("./constants");
@@ -103,6 +103,45 @@ const writeSNFileCurry = (checkExists) => async (file, parentPath) => {
     }
 };
 exports.writeSNFileCurry = writeSNFileCurry;
+/**
+ * Writes the SN file to disk only if the local content differs from `file.content`.
+ * Returns `true` if the file was written (missing or differed), `false` if skipped.
+ *
+ * Used by `sinc refresh` to pull ServiceNow-side edits without churning unchanged
+ * files (preserves mtime, avoids noisy watchers, keeps diff output clean).
+ */
+const writeSNFileIfDifferent = async (file, parentPath) => {
+    let { name, type, content = "" } = file;
+    if (!content)
+        content = "";
+    const fullPath = path_1.default.join(parentPath, `${name}.${type}`);
+    let localContent = null;
+    try {
+        localContent = await fs_1.promises.readFile(fullPath, "utf8");
+    }
+    catch (e) {
+        localContent = null;
+    }
+    if (localContent === content) {
+        FileLogger_1.fileLogger.debug("Unchanged: " + fullPath);
+        return false;
+    }
+    if (localContent !== null) {
+        FileLogger_1.fileLogger.debug("Overwriting local content (differs from instance): " + fullPath);
+    }
+    else {
+        FileLogger_1.fileLogger.debug("Writing (missing locally): " + fullPath);
+    }
+    try {
+        await fs_1.promises.writeFile(fullPath, content);
+        return true;
+    }
+    catch (error) {
+        FileLogger_1.fileLogger.error("Failed to write " + fullPath + ":", error);
+        throw error;
+    }
+};
+exports.writeSNFileIfDifferent = writeSNFileIfDifferent;
 const createDirRecursively = async (path) => {
     await fs_1.promises.mkdir(path, { recursive: true });
 };

package/dist/MultiScopeWatcher.js

@@ -220,7 +220,8 @@ class MultiScopeWatcherManager {
                 if (curSysId && curName) {
                     var isDefault = curName === "Default" || curName.toLowerCase().indexOf("default") !== -1;
                     if (isDefault) {
-                        Logger_1.logger.warn(`[${scopeName}] No update set configured and current update set is Default. ` +
+                        Logger_1.logger.warn(`[${scopeName}] No update set configured for scope ${scopeName}. ` +
+                            `Changes will go to Default. ` +
                             `Use sinc createUpdateSet or activate a task in the dashboard.`);
                     }
                     else {
@@ -233,12 +234,14 @@ class MultiScopeWatcherManager {
                 }
                 else {
                     Logger_1.logger.warn(`[${scopeName}] No update set configured for scope ${scopeName}. ` +
+                        `Changes will go to Default. ` +
                         `Use sinc createUpdateSet or activate a task in the dashboard.`);
                 }
             }
             catch (queryErr) {
-                Logger_1.logger.warn(`[${scopeName}] No update set configured and could not query current update set. ` +
-                    `Changes will use direct Table API. Use sinc createUpdateSet or activate a task in the dashboard.`);
+                Logger_1.logger.warn(`[${scopeName}] No update set configured for scope ${scopeName}. ` +
+                    `Changes will go to Default (could not query current update set). ` +
+                    `Use sinc createUpdateSet or activate a task in the dashboard.`);
             }
             return;
         }

package/dist/appUtils.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAndAssignUpdateSet = exports.swapScope = exports.buildFiles = exports.summarizeRecord = exports.pushFiles = exports.getAppFileList = exports.groupAppFiles = exports.processMissingFiles = exports.findMissingFiles = exports.syncManifest = exports.processManifest = exports.normalizeManifestKeys = void 0;
+exports.createAndAssignUpdateSet = exports.swapScope = exports.buildFiles = exports.summarizeRecord = exports.pushFiles = exports.getAppFileList = exports.groupAppFiles = exports.processMissingFiles = exports.refreshAllFiles = exports.findMissingFiles = exports.syncManifest = exports.processManifest = exports.normalizeManifestKeys = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const progress_1 = __importDefault(require("progress"));
@@ -46,6 +46,7 @@ const constants_1 = require("./constants");
 const PluginManager_1 = __importDefault(require("./PluginManager"));
 const FileLogger_1 = require("./FileLogger");
 const snClient_1 = require("./snClient");
+const benchmark_1 = require("./benchmark");
 const Logger_1 = require("./Logger");
 const genericUtils_1 = require("./genericUtils");
 const getUpdateSetConfig = () => {
@@ -186,7 +187,16 @@ const processManifest = async (manifest, forceWrite = false, sourcePath) => {
     }
 };
 exports.processManifest = processManifest;
-const syncManifest = async (scope) => {
+const syncManifest = async (scope, options = {}) => {
+    // Top-level entry owns the collector lifecycle. Recursive calls (all-scopes
+    // → per-scope) inherit the collector via options._benchmarkCollector.
+    var isBenchmarkOwner = false;
+    var collector = options._benchmarkCollector;
+    if (options.benchmark && !collector) {
+        collector = new benchmark_1.BenchmarkCollector();
+        (0, snClient_1.setBenchmarkSink)(collector);
+        isBenchmarkOwner = true;
+    }
     try {
         const curManifest = await ConfigManager.getManifest();
         if (!curManifest)
@@ -239,7 +249,12 @@ const syncManifest = async (scope) => {
             const refreshTableCount = Object.keys(newManifest.tables).length;
             FileLogger_1.fileLogger.debug("Refreshed manifest for " + scope + ": " + refreshTableCount + " tables");
             await fUtils.writeScopeManifest(scope, newManifest);
-            await (0, exports.processMissingFiles)(newManifest, scopeSourcePath);
+            if (collector)
+                collector.startScope(scope);
+            await (0, exports.refreshAllFiles)(newManifest, scopeSourcePath, {
+                force: options.force,
+                benchmarkCollector: collector,
+            });
             // Update the in-memory manifest for this scope
             if (ConfigManager.isMultiScopeManifest(curManifest)) {
                 curManifest[scope] = newManifest;
@@ -250,20 +265,24 @@ const syncManifest = async (scope) => {
             // Sync all scopes. Prefer the declared-scopes list (config.scopes) over
             // the persisted manifest keys — the manifest may contain stale undeclared
             // scopes that leaked in before the whitelist gate existed.
+            var childOptions = {
+                force: options.force,
+                _benchmarkCollector: collector,
+            };
             if (declaredScopes.length > 0) {
                 for (var d = 0; d < declaredScopes.length; d++) {
-                    await (0, exports.syncManifest)(declaredScopes[d]);
+                    await (0, exports.syncManifest)(declaredScopes[d], childOptions);
                 }
             }
             else if (ConfigManager.isMultiScopeManifest(curManifest)) {
                 // No declared scopes — fall back to the persisted manifest's scopes.
                 for (const scopeName of Object.keys(curManifest)) {
-                    await (0, exports.syncManifest)(scopeName);
+                    await (0, exports.syncManifest)(scopeName, childOptions);
                 }
             }
             else if (curManifest.scope) {
                 // Single scope manifest
-                await (0, exports.syncManifest)(curManifest.scope);
+                await (0, exports.syncManifest)(curManifest.scope, childOptions);
             }
         }
     }
@@ -275,6 +294,12 @@ const syncManifest = async (scope) => {
             message = String(e);
         Logger_1.logger.error("Refresh failed: " + message);
     }
+    finally {
+        if (isBenchmarkOwner && collector) {
+            (0, snClient_1.setBenchmarkSink)(null);
+            Logger_1.logger.info(collector.formatSummary());
+        }
+    }
 };
 exports.syncManifest = syncManifest;
 const markFileMissing = (missingObj) => (table) => (recordId) => (file) => {
@@ -351,6 +376,153 @@ exports.findMissingFiles = findMissingFiles;
 // Must mirror the chunk size used by allScopesCommands.ts (watch path) so behaviour
 // is consistent across `refresh` and `watch`.
 const BULK_DOWNLOAD_TABLE_CHUNK_SIZE = 5;
+/**
+ * Builds a MissingFileTableMap containing EVERY file in the manifest — ignores
+ * local disk state. Used by `sinc refresh` to pull instance-side edits down.
+ */
+const buildAllFilesMap = (manifest) => {
+    const result = {};
+    const { tables } = manifest;
+    const tableNames = Object.keys(tables);
+    for (var t = 0; t < tableNames.length; t++) {
+        var tableName = tableNames[t];
+        var records = tables[tableName].records;
+        var recNames = Object.keys(records);
+        if (recNames.length === 0)
+            continue;
+        var recMap = {};
+        for (var r = 0; r < recNames.length; r++) {
+            var rec = records[recNames[r]];
+            if (!rec.files || rec.files.length === 0)
+                continue;
+            // Strip any content that may be lingering on manifest file entries; the
+            // bulkDownload endpoint only needs name + type to resolve each field.
+            recMap[rec.sys_id] = rec.files.map(function (f) {
+                return { name: f.name, type: f.type };
+            });
+        }
+        if (Object.keys(recMap).length > 0)
+            result[tableName] = recMap;
+    }
+    return result;
+};
+/**
+ * Refreshes local files against the ServiceNow instance for every file in the
+ * given manifest. Unlike `processMissingFiles` (which only writes files absent
+ * from disk), this walks ALL manifest files, fetches their current content from
+ * the instance, and writes when content differs.
+ *
+ * @param options.force — when true, always overwrite local files even if their
+ * content matches the instance. Use for deliberate "reset local to instance".
+ */
+const refreshAllFiles = async (newManifest, sourcePath, options = {}) => {
+    try {
+        const allFiles = buildAllFilesMap(newManifest);
+        const tableNames = Object.keys(allFiles);
+        if (tableNames.length === 0)
+            return;
+        FileLogger_1.fileLogger.debug("Refreshing file content for " + tableNames.length + " tables (force=" + !!options.force + ")");
+        const { tableOptions = {} } = ConfigManager.getConfig();
+        const client = (0, snClient_1.defaultClient)();
+        const totalChunks = Math.ceil(tableNames.length / BULK_DOWNLOAD_TABLE_CHUNK_SIZE);
+        const filesToProcess = {};
+        for (var i = 0; i < tableNames.length; i += BULK_DOWNLOAD_TABLE_CHUNK_SIZE) {
+            const chunkTableNames = tableNames.slice(i, i + BULK_DOWNLOAD_TABLE_CHUNK_SIZE);
+            const chunkMissing = {};
+            for (var j = 0; j < chunkTableNames.length; j++) {
+                chunkMissing[chunkTableNames[j]] = allFiles[chunkTableNames[j]];
+            }
+            const batchNum = Math.floor(i / BULK_DOWNLOAD_TABLE_CHUNK_SIZE) + 1;
+            FileLogger_1.fileLogger.debug("Refresh download batch " + batchNum + "/" + totalChunks +
+                " (" + chunkTableNames.length + " tables): " + chunkTableNames.join(", "));
+            const chunkResult = await (0, snClient_1.unwrapSNResponse)(client.getMissingFiles(chunkMissing, tableOptions));
+            for (var tableName in chunkResult) {
+                filesToProcess[tableName] = chunkResult[tableName];
+            }
+        }
+        var basePath = sourcePath || ConfigManager.getSourcePath();
+        var recordCount = countRecordsInTables(filesToProcess);
+        var progress = createScopeProgress(Logger_1.logger.getLogLevel(), {
+            scope: newManifest.scope || "default",
+            total: recordCount,
+        });
+        var writtenCount = 0;
+        var unchangedCount = 0;
+        const forceWrite = !!options.force;
+        const forceWriter = fUtils.writeSNFileCurry(false);
+        const processedTableNames = Object.keys(filesToProcess);
+        await (0, genericUtils_1.processBatched)(processedTableNames, constants_1.CONCURRENCY_TABLES, async function (tableName) {
+            var tablePath = path_1.default.join(basePath, tableName);
+            var recs = filesToProcess[tableName].records;
+            var recKeys = Object.keys(recs);
+            await Promise.all(recKeys.map(function (k) {
+                return fUtils.createDirRecursively(path_1.default.join(tablePath, recs[k].name));
+            }));
+            await (0, genericUtils_1.processBatched)(recKeys, constants_1.CONCURRENCY_RECORDS, async function (recKey) {
+                var rec = recs[recKey];
+                var recPath = path_1.default.join(tablePath, rec.name);
+                var results = await (0, genericUtils_1.allSettledBatched)(rec.files, constants_1.CONCURRENCY_FILES, async function (file) {
+                    if (forceWrite) {
+                        await forceWriter(file, recPath);
+                        return true;
+                    }
+                    return fUtils.writeSNFileIfDifferent(file, recPath);
+                });
+                var anyChanged = false;
+                for (var f = 0; f < results.length; f++) {
+                    var res = results[f];
+                    if (res.status === "rejected") {
+                        FileLogger_1.fileLogger.error("File write failed: " + res.reason);
+                        continue;
+                    }
+                    if (res.value) {
+                        anyChanged = true;
+                        writtenCount++;
+                    }
+                    else {
+                        unchangedCount++;
+                    }
+                }
+                // Only touch metaData when at least one file in the record actually
+                // changed. Avoids rewriting _lastUpdatedOn for records that were
+                // already in sync with the instance.
+                if (anyChanged || forceWrite) {
+                    const metadataFile = {
+                        name: "metaData",
+                        type: "json",
+                        content: JSON.stringify({ _lastUpdatedOn: new Date().toISOString() }, null, 2),
+                    };
+                    await forceWriter(metadataFile, recPath);
+                }
+                // Strip content from manifest entries to keep memory bounded.
+                rec.files = rec.files.map(function (file) {
+                    var copy = Object.assign({}, file);
+                    delete copy.content;
+                    return copy;
+                });
+                progress.tick();
+            });
+        });
+        FileLogger_1.fileLogger.debug("Refresh complete: " + writtenCount + " written, " + unchangedCount + " unchanged");
+        if (writtenCount > 0) {
+            Logger_1.logger.info("Refreshed " + writtenCount + " file(s) from instance" +
+                (unchangedCount > 0 ? " (" + unchangedCount + " already in sync)" : ""));
+        }
+        else {
+            Logger_1.logger.debug("No file changes detected from instance (" + unchangedCount + " checked)");
+        }
+        if (options.benchmarkCollector) {
+            options.benchmarkCollector.endScope(writtenCount, unchangedCount);
+        }
+    }
+    catch (e) {
+        if (options.benchmarkCollector) {
+            options.benchmarkCollector.endScope(0, 0);
+        }
+        throw e;
+    }
+};
+exports.refreshAllFiles = refreshAllFiles;
 const processMissingFiles = async (newManifest, sourcePath) => {
     try {
         const missing = await (0, exports.findMissingFiles)(newManifest, sourcePath);

package/dist/benchmark.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * Opt-in benchmark collector for `sinc refresh`. Wired into snClient via
+ * setBenchmarkSink — when null (the default), there is zero overhead.
+ *
+ * PR #36 changed refresh from "download files absent from disk" to "bulk-download
+ * every manifest file and compare before writing". That shifted the request
+ * profile silently. This collector surfaces the numbers so regressions are
+ * visible.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BenchmarkCollector = void 0;
+class BenchmarkCollector {
+    httpSamples = [];
+    scopeSamples = [];
+    currentScope = null;
+    recordHttp(sample) {
+        this.httpSamples.push(sample);
+    }
+    startScope(scopeName) {
+        this.currentScope = {
+            name: scopeName,
+            startedAt: Date.now(),
+            httpStart: this.httpSamples.length,
+            bytesStart: this.totalBytes(),
+        };
+    }
+    endScope(filesWritten, filesUnchanged) {
+        if (!this.currentScope)
+            return;
+        var scope = this.currentScope;
+        this.scopeSamples.push({
+            scopeName: scope.name,
+            wallTimeMs: Date.now() - scope.startedAt,
+            httpRequests: this.httpSamples.length - scope.httpStart,
+            filesWritten: filesWritten,
+            filesUnchanged: filesUnchanged,
+            totalResponseBytes: this.totalBytes() - scope.bytesStart,
+        });
+        this.currentScope = null;
+    }
+    getHttpSamples() {
+        return this.httpSamples.slice();
+    }
+    getScopeSamples() {
+        return this.scopeSamples.slice();
+    }
+    totalBytes() {
+        var total = 0;
+        for (var i = 0; i < this.httpSamples.length; i++) {
+            total += this.httpSamples[i].responseBytes;
+        }
+        return total;
+    }
+    formatSummary() {
+        var lines = [];
+        lines.push("");
+        lines.push("=".repeat(72));
+        lines.push("Refresh Benchmark");
+        lines.push("=".repeat(72));
+        if (this.httpSamples.length === 0) {
+            lines.push("(no samples recorded)");
+            return lines.join("\n");
+        }
+        var latencies = this.httpSamples
+            .map(function (s) { return s.durationMs; })
+            .sort(function (a, b) { return a - b; });
+        var p50 = percentile(latencies, 0.5);
+        var p95 = percentile(latencies, 0.95);
+        var max = latencies[latencies.length - 1];
+        var totalBytes = this.totalBytes();
+        lines.push("Overall: " + this.httpSamples.length + " HTTP requests, " +
+            formatBytes(totalBytes) + " received");
+        lines.push("Latency: p50 " + p50 + "ms | p95 " + p95 + "ms | max " + max + "ms");
+        if (this.scopeSamples.length > 0) {
+            lines.push("");
+            lines.push("Per-scope:");
+            for (var i = 0; i < this.scopeSamples.length; i++) {
+                var s = this.scopeSamples[i];
+                lines.push("  " + s.scopeName + ": " +
+                    s.wallTimeMs + "ms wall, " +
+                    s.httpRequests + " req, " +
+                    formatBytes(s.totalResponseBytes) + ", " +
+                    s.filesWritten + " written / " + s.filesUnchanged + " unchanged");
+            }
+        }
+        lines.push("=".repeat(72));
+        return lines.join("\n");
+    }
+}
+exports.BenchmarkCollector = BenchmarkCollector;
+function percentile(sortedAsc, p) {
+    if (sortedAsc.length === 0)
+        return 0;
+    var idx = Math.min(sortedAsc.length - 1, Math.floor(sortedAsc.length * p));
+    return sortedAsc[idx];
+}
+function formatBytes(n) {
+    if (n < 1024)
+        return n + "B";
+    if (n < 1024 * 1024)
+        return (n / 1024).toFixed(1) + "KB";
+    return (n / (1024 * 1024)).toFixed(2) + "MB";
+}

package/dist/commander.js

@@ -50,7 +50,31 @@ async function initCommands() {
     }, async (args) => {
         await (0, allScopesCommands_1.watchAllScopesCommand)(args);
     })
-        .command(["refresh", "r"], "Refresh Manifest and download new files since last refresh", sharedOptions, commands_1.refreshCommand)
+        .command(["refresh", "r"], "Pull latest manifest and file contents from the ServiceNow instance", (cmdArgs) => {
+        cmdArgs.options({
+            ...sharedOptions,
+            force: {
+                alias: "f",
+                type: "boolean",
+                default: false,
+                describe: "Overwrite local files even when content matches the instance",
+            },
+            scope: {
+                alias: "s",
+                type: "string",
+                describe: "Refresh a single scope (default: all declared scopes)",
+            },
+            benchmark: {
+                alias: "b",
+                type: "boolean",
+                default: false,
+                describe: "Log per-scope and aggregate HTTP latency, bytes, and file counts",
+            },
+        });
+        return cmdArgs;
+    }, async (args) => {
+        await (0, commands_1.refreshCommand)(args);
+    })
         .command(["push [target]"], "[DESTRUCTIVE] Push all files from current local files to ServiceNow instance.", (cmdArgs) => {
         cmdArgs.options({
             ...sharedOptions,

package/dist/commands.js

@@ -65,8 +65,11 @@ async function refreshCommand(args, log = true) {
     try {
         if (!log)
             setLogLevel({ logLevel: "warn" });
-        FileLogger_1.fileLogger.debug("Syncing manifest from instance");
-        await AppUtils.syncManifest();
+        FileLogger_1.fileLogger.debug("Syncing manifest from instance (force=" + !!args.force + ", benchmark=" + !!args.benchmark + ")");
+        await AppUtils.syncManifest(args.scope, {
+            force: !!args.force,
+            benchmark: !!args.benchmark,
+        });
         Logger_1.logger.success("Refresh complete!");
         setLogLevel(args);
     }

package/dist/snClient.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.unwrapSNResponse = exports.defaultClient = exports.snClient = exports.processPushResponse = exports.retryOnHttpErr = exports.retryOnErr = void 0;
+exports.setBenchmarkSink = setBenchmarkSink;
 exports.unwrapTableAPIFirstItem = unwrapTableAPIFirstItem;
 const axios_1 = __importDefault(require("axios"));
 const axios_cookiejar_support_1 = require("axios-cookiejar-support");
@@ -12,6 +13,11 @@ const tough_cookie_1 = require("tough-cookie");
 const genericUtils_1 = require("./genericUtils");
 const Logger_1 = require("./Logger");
 const FileLogger_1 = require("./FileLogger");
+// Benchmark sink. Null when --benchmark is off; zero overhead in that case.
+let _benchmarkSink = null;
+function setBenchmarkSink(sink) {
+    _benchmarkSink = sink;
+}
 // Local helper to strip _ directive keys before sending to ServiceNow API.
 // Defined here (not imported from config.ts) to avoid circular dependencies.
 function _stripUnderscoreKeys(obj) {
@@ -143,7 +149,7 @@ const processPushResponse = (response, recSummary) => {
 exports.processPushResponse = processPushResponse;
 const snClient = (baseURL, username, password) => {
     const jar = new tough_cookie_1.CookieJar();
-    const client = (0, axios_rate_limit_1.default)((0, axios_cookiejar_support_1.wrapper)(axios_1.default.create({
+    const rawAxios = (0, axios_cookiejar_support_1.wrapper)(axios_1.default.create({
         withCredentials: true,
         auth: {
             username,
@@ -154,7 +160,55 @@ const snClient = (baseURL, username, password) => {
         },
         baseURL,
         jar,
-    })), { maxRPS: 20 });
+    }));
+    // Request interceptor: stamp startedAt so the response interceptor can
+    // compute durationMs. Only when a benchmark sink is attached — when it
+    // isn't, this is a single property assignment and does not change shape.
+    rawAxios.interceptors.request.use(function (cfg) {
+        if (_benchmarkSink) {
+            cfg._benchStartedAt = Date.now();
+        }
+        return cfg;
+    });
+    rawAxios.interceptors.response.use(function (response) {
+        if (!_benchmarkSink)
+            return response;
+        var startedAt = response.config && response.config._benchStartedAt;
+        if (!startedAt)
+            return response;
+        var url = (response.config && response.config.url) || "";
+        var payload = response.data;
+        var responseBytes = 0;
+        try {
+            responseBytes = payload ? JSON.stringify(payload).length : 0;
+        }
+        catch (e) {
+            responseBytes = 0;
+        }
+        var tableCount = 0;
+        var result = payload && payload.result;
+        if (result && typeof result === "object") {
+            if (url.indexOf("bulkDownload") !== -1) {
+                tableCount = Object.keys(result).length;
+            }
+            else if (url.indexOf("getManifest") !== -1 && result.tables) {
+                tableCount = Object.keys(result.tables).length;
+            }
+        }
+        _benchmarkSink.recordHttp({
+            path: url,
+            tableCount: tableCount,
+            durationMs: Date.now() - startedAt,
+            statusCode: response.status,
+            responseBytes: responseBytes,
+        });
+        return response;
+    }, function (error) {
+        // Preserve original rejection; don't record errored requests (they skew
+        // latency tails without adding signal for the "scales the same" question).
+        return Promise.reject(error);
+    });
+    const client = (0, axios_rate_limit_1.default)(rawAxios, { maxRPS: 20 });
     const getAppList = () => {
         const endpoint = "api/sinc/sincronia/getAppList";
         return client.get(endpoint);

package/dist/tests/benchmarkRefresh.test.js

@@ -0,0 +1,265 @@
+"use strict";
+/**
+ * Unit tests for the --benchmark flag on `sinc refresh`.
+ *
+ * Two layers:
+ *   1. BenchmarkCollector in isolation — covers p50/p95/max math and the
+ *      formatSummary string the CLI prints.
+ *   2. refreshAllFiles wired to a collector — asserts startScope/endScope
+ *      bookends the scope and that filesWritten/filesUnchanged match what
+ *      refresh actually did.
+ *
+ * The axios interceptor hook (snClient.setBenchmarkSink) is exercised by the
+ * real-run integration against workstudio — not here. This suite covers the
+ * collector contract and the appUtils lifecycle.
+ */
+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 });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const benchmark_1 = require("../benchmark");
+// ---------- mocks for refreshAllFiles test (must come before importing) ----
+var mockLogger = {
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    success: jest.fn(),
+    getLogLevel: function () { return "warn"; },
+};
+var mockFileLogger = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+};
+var mockClient = {
+    getManifest: jest.fn(),
+    getMissingFiles: jest.fn(),
+};
+jest.mock("../Logger", function () { return { logger: mockLogger }; });
+jest.mock("../FileLogger", function () { return { fileLogger: mockFileLogger }; });
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: function () { return mockClient; },
+        unwrapSNResponse: function (p) { return Promise.resolve(p).then(function (r) { return r; }); },
+        processPushResponse: jest.fn(),
+        retryOnErr: jest.fn(),
+        retryOnHttpErr: jest.fn(),
+        unwrapTableAPIFirstItem: jest.fn(),
+        setBenchmarkSink: jest.fn(),
+    };
+});
+var mockConfig = {
+    getConfig: jest.fn().mockReturnValue({ scopes: { x_cadso_core: {} }, tableOptions: {} }),
+    getManifest: jest.fn().mockResolvedValue({
+        x_cadso_core: { scope: "x_cadso_core", tables: {} },
+    }),
+    getSourcePathForScope: jest.fn(),
+    getSourcePath: jest.fn(),
+    getManifestPath: jest.fn().mockReturnValue("/tmp/sinc.manifest.json"),
+    resolveConfigForScope: jest.fn().mockImplementation(function () {
+        return { tables: ["sys_script_include"], fieldOverrides: {}, apiIncludes: {}, apiExcludes: {} };
+    }),
+    isMultiScopeManifest: jest.fn().mockReturnValue(true),
+    updateManifest: jest.fn(),
+};
+jest.mock("../config", function () { return mockConfig; });
+jest.mock("progress", function () {
+    return jest.fn().mockImplementation(function () { return { tick: jest.fn() }; });
+});
+jest.mock("../FileUtils", function () {
+    var actual = jest.requireActual("../FileUtils");
+    return Object.assign({}, actual, {
+        writeScopeManifest: jest.fn().mockResolvedValue(undefined),
+    });
+});
+const AppUtils = __importStar(require("../appUtils"));
+// ---------- collector unit tests ----------
+describe("BenchmarkCollector", function () {
+    test("formatSummary reports empty state when nothing recorded", function () {
+        var collector = new benchmark_1.BenchmarkCollector();
+        var summary = collector.formatSummary();
+        expect(summary).toContain("Refresh Benchmark");
+        expect(summary).toContain("(no samples recorded)");
+    });
+    test("percentiles reflect the recorded latencies", function () {
+        var collector = new benchmark_1.BenchmarkCollector();
+        // 10, 20, 30, ..., 100 — p50 at index 5 = 60, p95 at index 9 = 100.
+        for (var i = 1; i <= 10; i++) {
+            collector.recordHttp({
+                path: "/api/test",
+                tableCount: 1,
+                durationMs: i * 10,
+                statusCode: 200,
+                responseBytes: 100,
+            });
+        }
+        var summary = collector.formatSummary();
+        expect(summary).toContain("p50 60ms");
+        expect(summary).toContain("p95 100ms");
+        expect(summary).toContain("max 100ms");
+        expect(summary).toContain("10 HTTP requests");
+    });
+    test("scope samples record wall time, request counts, and file counts", function () {
+        var collector = new benchmark_1.BenchmarkCollector();
+        collector.startScope("x_cadso_core");
+        collector.recordHttp({
+            path: "/api/bulkDownload",
+            tableCount: 3,
+            durationMs: 50,
+            statusCode: 200,
+            responseBytes: 2048,
+        });
+        collector.recordHttp({
+            path: "/api/bulkDownload",
+            tableCount: 3,
+            durationMs: 80,
+            statusCode: 200,
+            responseBytes: 4096,
+        });
+        collector.endScope(7, 42);
+        var scopes = collector.getScopeSamples();
+        expect(scopes).toHaveLength(1);
+        expect(scopes[0].scopeName).toBe("x_cadso_core");
+        expect(scopes[0].httpRequests).toBe(2);
+        expect(scopes[0].totalResponseBytes).toBe(2048 + 4096);
+        expect(scopes[0].filesWritten).toBe(7);
+        expect(scopes[0].filesUnchanged).toBe(42);
+        expect(scopes[0].wallTimeMs).toBeGreaterThanOrEqual(0);
+        var summary = collector.formatSummary();
+        expect(summary).toContain("x_cadso_core:");
+        expect(summary).toContain("7 written / 42 unchanged");
+    });
+    test("formatBytes switches units at KB and MB thresholds", function () {
+        var collector = new benchmark_1.BenchmarkCollector();
+        collector.recordHttp({ path: "/a", tableCount: 1, durationMs: 1, statusCode: 200, responseBytes: 500 });
+        expect(collector.formatSummary()).toContain("500B received");
+        var collector2 = new benchmark_1.BenchmarkCollector();
+        collector2.recordHttp({ path: "/a", tableCount: 1, durationMs: 1, statusCode: 200, responseBytes: 2048 });
+        expect(collector2.formatSummary()).toContain("2.0KB received");
+        var collector3 = new benchmark_1.BenchmarkCollector();
+        collector3.recordHttp({ path: "/a", tableCount: 1, durationMs: 1, statusCode: 200, responseBytes: 2 * 1024 * 1024 });
+        expect(collector3.formatSummary()).toContain("2.00MB received");
+    });
+    test("endScope is a no-op when no scope is active", function () {
+        var collector = new benchmark_1.BenchmarkCollector();
+        collector.endScope(5, 5);
+        expect(collector.getScopeSamples()).toHaveLength(0);
+    });
+});
+// ---------- refreshAllFiles integration with collector ----------
+describe("refreshAllFiles — benchmarkCollector lifecycle", function () {
+    var tmpRoot;
+    beforeEach(function () {
+        jest.clearAllMocks();
+        tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "sinc-bench-test-"));
+        mockConfig.getSourcePathForScope.mockReturnValue(tmpRoot);
+        mockConfig.getSourcePath.mockReturnValue(tmpRoot);
+    });
+    afterEach(function () {
+        try {
+            fs.rmSync(tmpRoot, { recursive: true, force: true });
+        }
+        catch (e) { }
+    });
+    test("endScope captures filesWritten and filesUnchanged for a refresh pass", async function () {
+        // "Stale" file — content diverges from what the mock returns → will be written.
+        fs.mkdirSync(path.join(tmpRoot, "sys_script_include", "StaleRec"), { recursive: true });
+        fs.writeFileSync(path.join(tmpRoot, "sys_script_include", "StaleRec", "script.js"), "var x = 1;");
+        // "Matching" file — content matches → counted as unchanged.
+        fs.mkdirSync(path.join(tmpRoot, "sys_script_include", "SameRec"), { recursive: true });
+        var matching = "var same = true;";
+        fs.writeFileSync(path.join(tmpRoot, "sys_script_include", "SameRec", "script.js"), matching);
+        var manifest = {
+            scope: "x_cadso_core",
+            tables: {
+                sys_script_include: {
+                    records: {
+                        StaleRec: { name: "StaleRec", sys_id: "sysid_Stale", files: [{ name: "script", type: "js" }] },
+                        SameRec: { name: "SameRec", sys_id: "sysid_Same", files: [{ name: "script", type: "js" }] },
+                    },
+                },
+            },
+        };
+        mockClient.getManifest.mockResolvedValue(manifest);
+        mockClient.getMissingFiles.mockResolvedValue({
+            sys_script_include: {
+                records: {
+                    StaleRec: {
+                        name: "StaleRec", sys_id: "sysid_Stale",
+                        files: [{ name: "script", type: "js", content: "var x = 99; // new from instance" }],
+                    },
+                    SameRec: {
+                        name: "SameRec", sys_id: "sysid_Same",
+                        files: [{ name: "script", type: "js", content: matching }],
+                    },
+                },
+            },
+        });
+        var collector = new benchmark_1.BenchmarkCollector();
+        collector.startScope("x_cadso_core");
+        await AppUtils.refreshAllFiles(manifest, tmpRoot, {
+            benchmarkCollector: collector,
+        });
+        var scopes = collector.getScopeSamples();
+        expect(scopes).toHaveLength(1);
+        expect(scopes[0].scopeName).toBe("x_cadso_core");
+        // One file had divergent content → written. One matched → unchanged.
+        expect(scopes[0].filesWritten).toBe(1);
+        expect(scopes[0].filesUnchanged).toBe(1);
+    });
+    test("endScope(0, 0) on error path so the collector still closes cleanly", async function () {
+        mockClient.getMissingFiles.mockRejectedValue(new Error("boom"));
+        var manifest = {
+            scope: "x_cadso_core",
+            tables: {
+                sys_script_include: {
+                    records: {
+                        Rec: { name: "Rec", sys_id: "sysid_Rec", files: [{ name: "script", type: "js" }] },
+                    },
+                },
+            },
+        };
+        var collector = new benchmark_1.BenchmarkCollector();
+        collector.startScope("x_cadso_core");
+        await expect(AppUtils.refreshAllFiles(manifest, tmpRoot, { benchmarkCollector: collector })).rejects.toThrow("boom");
+        var scopes = collector.getScopeSamples();
+        expect(scopes).toHaveLength(1);
+        expect(scopes[0].filesWritten).toBe(0);
+        expect(scopes[0].filesUnchanged).toBe(0);
+    });
+});

package/dist/tests/globalDebounce.test.js

@@ -86,6 +86,7 @@ var mockSNClient = {
     updateCurrentAppUserPref: jest.fn(),
     createCurrentAppUserPref: jest.fn(),
     getCurrentUpdateSetUserPref: jest.fn(),
+    changeScope: jest.fn().mockResolvedValue(undefined),
 };
 jest.mock("../snClient", function () {
     return {
@@ -267,9 +268,9 @@ describe("US-014: Global debounce for serialized scope processing", function ()
         watcherB.pushQueue.push(ctxB.filePath);
         // Track the order of scope switches
         var switchOrder = [];
-        mockSNClient.getScopeId.mockImplementation(function (scope) {
+        mockSNClient.changeScope.mockImplementation(function (scope) {
             switchOrder.push(scope);
-            return Promise.resolve([{ sys_id: "scope_sys_id_" + scope }]);
+            return Promise.resolve(undefined);
         });
         // Fire the global debounce
         await capturedDebounceFns[0]();

package/dist/tests/multi-scope-watcher.test.js

@@ -83,6 +83,7 @@ const mockSNClient = {
     updateCurrentAppUserPref: jest.fn(),
     createCurrentAppUserPref: jest.fn(),
     getCurrentUpdateSetUserPref: jest.fn(),
+    changeScope: jest.fn().mockResolvedValue(undefined),
 };
 jest.mock("../snClient", () => ({
     defaultClient: jest.fn(() => mockSNClient),
@@ -415,28 +416,17 @@ describe("MultiScopeWatcherManager", () => {
         });
     });
     describe("switchToScope", () => {
-        it("updates existing preference when one exists", async () => {
-            mockSNClient.getCurrentAppUserPrefSysId.mockResolvedValue([{ sys_id: "existing_pref" }]);
-            // Access private method
+        // switchToScope now uses the Claude REST API changeScope endpoint
+        // (gs.setCurrentApplicationId) to switch the active REST session scope.
+        // The previous user-preference approach only wrote a DB record and did
+        // not affect the session, causing updateRecord() to operate in the wrong scope.
+        it("invokes client.changeScope with the target scope", async () => {
             await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_test_core");
-            expect(mockSNClient.getScopeId).toHaveBeenCalledWith("x_test_core");
-            expect(mockSNClient.getUserSysId).toHaveBeenCalled();
-            expect(mockSNClient.updateCurrentAppUserPref).toHaveBeenCalledWith("scope_sys_id", "existing_pref");
-            expect(mockSNClient.createCurrentAppUserPref).not.toHaveBeenCalled();
+            expect(mockSNClient.changeScope).toHaveBeenCalledWith("x_test_core");
         });
-        it("creates new preference when none exists", async () => {
-            mockSNClient.getCurrentAppUserPrefSysId.mockResolvedValue([]);
-            await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_test_core");
-            expect(mockSNClient.createCurrentAppUserPref).toHaveBeenCalledWith("scope_sys_id", "user_sys_id");
-            expect(mockSNClient.updateCurrentAppUserPref).not.toHaveBeenCalled();
-        });
-        it("throws when scope not found", async () => {
-            mockSNClient.getScopeId.mockResolvedValue([]);
-            await expect(MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_missing")).rejects.toThrow("Scope x_missing not found");
-        });
-        it("throws when user sys_id cannot be retrieved", async () => {
-            mockSNClient.getUserSysId.mockResolvedValue([]);
-            await expect(MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_test_core")).rejects.toThrow("Could not get user sys_id");
+        it("propagates errors from changeScope and invalidates cached scope", async () => {
+            mockSNClient.changeScope.mockRejectedValueOnce(new Error("changeScope failed"));
+            await expect(MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_test_core")).rejects.toThrow("changeScope failed");
         });
     });
     describe("loadScopeManifest", () => {

package/dist/tests/scopeCaching.test.js

@@ -26,6 +26,10 @@ jest.mock("../snClient", function () {
                 createCurrentAppUserPref: function (scopeSysId, userSysId) {
                     apiCalls.push("createCurrentAppUserPref");
                     return Promise.resolve({});
+                },
+                changeScope: function (scope) {
+                    apiCalls.push("changeScope:" + scope);
+                    return Promise.resolve(undefined);
                 }
             };
         },
@@ -56,16 +60,13 @@ jest.mock("../config", function () {
 describe("Scope Caching (US-013)", function () {
     beforeEach(function () {
         apiCalls = [];
-        // Reset cached state
+        // Reset cached state. switchToScope now uses the Claude REST API
+        // changeScope endpoint; the cache avoids redundant session switches.
         MultiScopeWatcher_1.multiScopeWatcher.cachedScope = null;
-        MultiScopeWatcher_1.multiScopeWatcher.cachedUserSysId = null;
     });
-    it("should make API calls on first switch to a scope", async function () {
+    it("should call changeScope on first switch to a scope", async function () {
         await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_core");
-        expect(apiCalls).toContain("getScopeId:x_cadso_core");
-        expect(apiCalls).toContain("getUserSysId");
-        expect(apiCalls).toContain("getCurrentAppUserPrefSysId");
-        expect(apiCalls).toContain("updateCurrentAppUserPref");
+        expect(apiCalls).toContain("changeScope:x_cadso_core");
     });
     it("should skip API calls when switching to the same scope (cache hit)", async function () {
         await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_core");
@@ -73,21 +74,11 @@ describe("Scope Caching (US-013)", function () {
         await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_core");
         expect(apiCalls).toEqual([]);
     });
-    it("should make API calls when switching to a different scope (cache miss)", async function () {
-        await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_core");
-        apiCalls = [];
-        await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_automate");
-        expect(apiCalls).toContain("getScopeId:x_cadso_automate");
-        expect(apiCalls).toContain("getCurrentAppUserPrefSysId");
-        expect(apiCalls).toContain("updateCurrentAppUserPref");
-    });
-    it("should cache getUserSysId and call it at most once across multiple scope switches", async function () {
+    it("should call changeScope when switching to a different scope (cache miss)", async function () {
         await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_core");
         apiCalls = [];
         await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_automate");
-        var userCalls = apiCalls.filter(function (c) { return c === "getUserSysId"; });
-        expect(userCalls).toHaveLength(0);
-        expect(MultiScopeWatcher_1.multiScopeWatcher.cachedUserSysId).toBe("user_abc123");
+        expect(apiCalls).toContain("changeScope:x_cadso_automate");
     });
     it("should update cachedScope after a successful switch", async function () {
         expect(MultiScopeWatcher_1.multiScopeWatcher.cachedScope).toBeNull();
@@ -100,14 +91,14 @@ describe("Scope Caching (US-013)", function () {
         // First successful switch
         await MultiScopeWatcher_1.multiScopeWatcher.switchToScope("x_cadso_core");
         expect(MultiScopeWatcher_1.multiScopeWatcher.cachedScope).toBe("x_cadso_core");
-        // Mock getScopeId to fail for a bad scope
+        // Swap in a client whose changeScope rejects
         var snClient = require("../snClient");
         var origDefault = snClient.defaultClient;
         snClient.defaultClient = function () {
             var client = origDefault();
-            client.getScopeId = function () {
-                apiCalls.push("getScopeId:bad_scope");
-                return Promise.resolve({ data: { result: [] } });
+            client.changeScope = function (scope) {
+                apiCalls.push("changeScope:" + scope + ":failed");
+                return Promise.reject(new Error("changeScope failed"));
             };
             return client;
         };

package/dist/tests/syncManifestRefresh.test.js

@@ -0,0 +1,287 @@
+"use strict";
+/**
+ * Tests for the refresh content-compare path.
+ *
+ * Regression target: `npx sinc refresh` previously only downloaded files that
+ * were absent from disk. Files edited on the ServiceNow instance would never
+ * propagate to a developer's local copy — the refresh command silently
+ * skipped existing files without checking content.
+ *
+ * These tests assert:
+ *   1. refresh fetches content for EVERY file in the manifest (not just missing)
+ *   2. Files whose local content differs are overwritten
+ *   3. Files whose local content matches are left alone (no rewrite)
+ *   4. Files missing locally are created
+ *   5. --force bypasses the content check and writes all files unconditionally
+ */
+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 });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+// ---------- mocks (must come before importing the module under test) ----------
+var mockLogger = {
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    success: jest.fn(),
+    getLogLevel: function () { return "warn"; },
+};
+var mockFileLogger = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+};
+var mockClient = {
+    getManifest: jest.fn(),
+    getMissingFiles: jest.fn(),
+};
+jest.mock("../Logger", function () { return { logger: mockLogger }; });
+jest.mock("../FileLogger", function () { return { fileLogger: mockFileLogger }; });
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: function () { return mockClient; },
+        unwrapSNResponse: function (p) { return Promise.resolve(p).then(function (r) { return r; }); },
+        processPushResponse: jest.fn(),
+        retryOnErr: jest.fn(),
+        retryOnHttpErr: jest.fn(),
+        unwrapTableAPIFirstItem: jest.fn(),
+    };
+});
+var mockConfig = {
+    getConfig: jest.fn().mockReturnValue({
+        scopes: { x_cadso_core: {} },
+        tableOptions: {},
+    }),
+    getManifest: jest.fn().mockResolvedValue({
+        x_cadso_core: { scope: "x_cadso_core", tables: {} },
+    }),
+    getSourcePathForScope: jest.fn(),
+    getSourcePath: jest.fn(),
+    getManifestPath: jest.fn().mockReturnValue("/tmp/sinc.manifest.json"),
+    resolveConfigForScope: jest.fn().mockImplementation(function () {
+        return {
+            tables: ["sys_script_include"],
+            fieldOverrides: {},
+            apiIncludes: {},
+            apiExcludes: {},
+        };
+    }),
+    isMultiScopeManifest: jest.fn().mockReturnValue(true),
+    updateManifest: jest.fn(),
+};
+jest.mock("../config", function () { return mockConfig; });
+// Silence ProgressBar's stdout writes.
+jest.mock("progress", function () {
+    return jest.fn().mockImplementation(function () {
+        return { tick: jest.fn() };
+    });
+});
+// Stub writeScopeManifest so we don't actually write a manifest file. Leave
+// the other FileUtils exports (writeSNFileCurry, writeSNFileIfDifferent,
+// createDirRecursively, etc.) as real implementations so we can assert
+// against the file system.
+jest.mock("../FileUtils", function () {
+    var actual = jest.requireActual("../FileUtils");
+    return Object.assign({}, actual, {
+        writeScopeManifest: jest.fn().mockResolvedValue(undefined),
+    });
+});
+const AppUtils = __importStar(require("../appUtils"));
+// ---------- tmp dir scaffolding ----------
+var tmpRoot;
+function setupScope(files) {
+    // Build a manifest whose single table (sys_script_include) contains the
+    // supplied records/files. Content is stripped (manifests do not carry it).
+    var records = {};
+    files.forEach(function (f) {
+        if (!records[f.record]) {
+            records[f.record] = { name: f.record, sys_id: "sysid_" + f.record, files: [] };
+        }
+        records[f.record].files.push({ name: f.name, type: f.type });
+    });
+    return {
+        scope: "x_cadso_core",
+        tables: {
+            sys_script_include: { records: records },
+        },
+    };
+}
+function writeLocal(record, name, type, content) {
+    var recDir = path.join(tmpRoot, "sys_script_include", record);
+    fs.mkdirSync(recDir, { recursive: true });
+    fs.writeFileSync(path.join(recDir, name + "." + type), content);
+}
+function readLocal(record, name, type) {
+    var p = path.join(tmpRoot, "sys_script_include", record, name + "." + type);
+    try {
+        return fs.readFileSync(p, "utf8");
+    }
+    catch (e) {
+        return null;
+    }
+}
+function statMtime(record, name, type) {
+    var p = path.join(tmpRoot, "sys_script_include", record, name + "." + type);
+    return fs.statSync(p).mtimeMs;
+}
+describe("syncManifest — refresh pulls instance edits down", function () {
+    beforeEach(function () {
+        jest.clearAllMocks();
+        tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "sinc-refresh-test-"));
+        mockConfig.getSourcePathForScope.mockReturnValue(tmpRoot);
+        mockConfig.getSourcePath.mockReturnValue(tmpRoot);
+    });
+    afterEach(function () {
+        try {
+            fs.rmSync(tmpRoot, { recursive: true, force: true });
+        }
+        catch (e) { }
+    });
+    test("overwrites existing file when instance content differs", async function () {
+        writeLocal("Foo", "script", "js", "var x = 1;"); // stale local
+        var manifest = setupScope([{ record: "Foo", name: "script", type: "js", content: "" }]);
+        mockClient.getManifest.mockResolvedValue(manifest);
+        mockClient.getMissingFiles.mockResolvedValue({
+            sys_script_include: {
+                records: {
+                    Foo: {
+                        name: "Foo",
+                        sys_id: "sysid_Foo",
+                        files: [{ name: "script", type: "js", content: "var x = 2; // from instance" }],
+                    },
+                },
+            },
+        });
+        await AppUtils.syncManifest("x_cadso_core");
+        expect(mockClient.getMissingFiles).toHaveBeenCalledTimes(1);
+        expect(readLocal("Foo", "script", "js")).toBe("var x = 2; // from instance");
+    });
+    test("does not rewrite a file when content already matches", async function () {
+        var identical = "var answer = 42;";
+        writeLocal("Bar", "script", "js", identical);
+        var beforeMtime = statMtime("Bar", "script", "js");
+        var manifest = setupScope([{ record: "Bar", name: "script", type: "js", content: "" }]);
+        mockClient.getManifest.mockResolvedValue(manifest);
+        mockClient.getMissingFiles.mockResolvedValue({
+            sys_script_include: {
+                records: {
+                    Bar: {
+                        name: "Bar",
+                        sys_id: "sysid_Bar",
+                        files: [{ name: "script", type: "js", content: identical }],
+                    },
+                },
+            },
+        });
+        // Give the fs a moment so any write would register a different mtime.
+        await new Promise(function (r) { setTimeout(r, 10); });
+        await AppUtils.syncManifest("x_cadso_core");
+        expect(readLocal("Bar", "script", "js")).toBe(identical);
+        expect(statMtime("Bar", "script", "js")).toBe(beforeMtime);
+        // metaData should NOT be written when nothing changed in the record
+        expect(readLocal("Bar", "metaData", "json")).toBeNull();
+    });
+    test("creates the file when it is missing locally", async function () {
+        var manifest = setupScope([{ record: "Baz", name: "script", type: "js", content: "" }]);
+        mockClient.getManifest.mockResolvedValue(manifest);
+        mockClient.getMissingFiles.mockResolvedValue({
+            sys_script_include: {
+                records: {
+                    Baz: {
+                        name: "Baz",
+                        sys_id: "sysid_Baz",
+                        files: [{ name: "script", type: "js", content: "// fresh file" }],
+                    },
+                },
+            },
+        });
+        await AppUtils.syncManifest("x_cadso_core");
+        expect(readLocal("Baz", "script", "js")).toBe("// fresh file");
+        expect(readLocal("Baz", "metaData", "json")).not.toBeNull();
+    });
+    test("--force overwrites even when local content already matches", async function () {
+        var identical = "var same = true;";
+        writeLocal("Qux", "script", "js", identical);
+        var manifest = setupScope([{ record: "Qux", name: "script", type: "js", content: "" }]);
+        mockClient.getManifest.mockResolvedValue(manifest);
+        mockClient.getMissingFiles.mockResolvedValue({
+            sys_script_include: {
+                records: {
+                    Qux: {
+                        name: "Qux",
+                        sys_id: "sysid_Qux",
+                        files: [{ name: "script", type: "js", content: identical }],
+                    },
+                },
+            },
+        });
+        var beforeMtime = statMtime("Qux", "script", "js");
+        await new Promise(function (r) { setTimeout(r, 10); });
+        await AppUtils.syncManifest("x_cadso_core", { force: true });
+        // Force path rewrites regardless — mtime should advance.
+        expect(statMtime("Qux", "script", "js")).toBeGreaterThan(beforeMtime);
+        expect(readLocal("Qux", "metaData", "json")).not.toBeNull();
+    });
+    test("bulkDownload is requested for EVERY file in the manifest, not just missing ones", async function () {
+        writeLocal("RecA", "script", "js", "local A");
+        writeLocal("RecB", "script", "js", "local B");
+        var manifest = setupScope([
+            { record: "RecA", name: "script", type: "js", content: "" },
+            { record: "RecB", name: "script", type: "js", content: "" },
+        ]);
+        mockClient.getManifest.mockResolvedValue(manifest);
+        mockClient.getMissingFiles.mockResolvedValue({
+            sys_script_include: {
+                records: {
+                    RecA: {
+                        name: "RecA", sys_id: "sysid_RecA",
+                        files: [{ name: "script", type: "js", content: "local A" }],
+                    },
+                    RecB: {
+                        name: "RecB", sys_id: "sysid_RecB",
+                        files: [{ name: "script", type: "js", content: "local B" }],
+                    },
+                },
+            },
+        });
+        await AppUtils.syncManifest("x_cadso_core");
+        expect(mockClient.getMissingFiles).toHaveBeenCalledTimes(1);
+        var missingArg = mockClient.getMissingFiles.mock.calls[0][0];
+        expect(Object.keys(missingArg.sys_script_include).sort()).toEqual(["sysid_RecA", "sysid_RecB"]);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tenonhq/sincronia-core",
-  "version": "0.0.81",
+  "version": "0.0.82",
   "description": "Next-gen file syncer",
   "license": "GPL-3.0",
   "main": "./dist/index.js",