@tenonhq/sincronia-core 0.0.78 → 0.0.80

package/dist/tests/globalDebounce.test.js

@@ -0,0 +1,307 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function createMockWatcher() {
+    var handlers = {};
+    var mock = {
+        _handlers: handlers,
+        on: jest.fn(function (event, handler) {
+            if (!handlers[event])
+                handlers[event] = [];
+            handlers[event].push(handler);
+            return mock;
+        }),
+        close: jest.fn(),
+        _emit: function (event) {
+            var args = Array.prototype.slice.call(arguments, 1);
+            (handlers[event] || []).forEach(function (h) { h.apply(null, args); });
+        },
+    };
+    return mock;
+}
+var mockWatchers = [];
+jest.mock("chokidar", function () {
+    return {
+        watch: jest.fn(function () {
+            var w = createMockWatcher();
+            mockWatchers.push(w);
+            return w;
+        }),
+    };
+});
+// Capture debounce calls to verify single global debounce
+var capturedDebounceFns = [];
+jest.mock("lodash", function () {
+    var actual = jest.requireActual("lodash");
+    return {
+        ...actual,
+        debounce: jest.fn(function (fn) {
+            capturedDebounceFns.push(fn);
+            var wrapper = jest.fn();
+            wrapper.cancel = jest.fn();
+            wrapper.flush = jest.fn(function () { return fn(); });
+            return wrapper;
+        }),
+    };
+});
+var mockSNClient = {
+    getScopeId: jest.fn(),
+    getUserSysId: jest.fn(),
+    getCurrentAppUserPrefSysId: jest.fn(),
+    updateCurrentAppUserPref: jest.fn(),
+    createCurrentAppUserPref: jest.fn(),
+    getCurrentUpdateSetUserPref: jest.fn(),
+};
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: jest.fn(function () { return mockSNClient; }),
+        unwrapSNResponse: jest.fn(function (val) { return val; }),
+    };
+});
+jest.mock("../FileUtils", function () {
+    return {
+        getFileContextFromPath: jest.fn(),
+        getFileContextWithSkipReason: jest.fn(),
+    };
+});
+jest.mock("../appUtils", function () {
+    return {
+        groupAppFiles: jest.fn(),
+        pushFiles: jest.fn(),
+    };
+});
+jest.mock("../logMessages", function () {
+    return { logFilePush: jest.fn() };
+});
+jest.mock("../recentEdits", function () {
+    return { writeRecentEdit: jest.fn() };
+});
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            info: jest.fn(),
+            error: jest.fn(),
+            warn: jest.fn(),
+            debug: jest.fn(),
+            success: jest.fn(),
+            getLogLevel: jest.fn().mockReturnValue("info"),
+        },
+    };
+});
+jest.mock("../config", function () {
+    return {
+        loadConfigs: jest.fn().mockResolvedValue(undefined),
+        getConfig: jest.fn(),
+        getRootDir: jest.fn().mockReturnValue("/project"),
+        updateManifest: jest.fn(),
+        getManifest: jest.fn(),
+        getSourcePath: jest.fn().mockReturnValue("/project/src"),
+        getScopeManifestPath: jest.fn(function (scope) { return "/project/sinc.manifest." + scope + ".json"; }),
+        getManifestPath: jest.fn().mockReturnValue("/project/sinc.manifest.json"),
+    };
+});
+jest.mock("fs", function () {
+    return {
+        existsSync: jest.fn(),
+        readFileSync: jest.fn(),
+        writeFileSync: jest.fn(),
+        statSync: jest.fn().mockReturnValue({ mtimeMs: Date.now() }),
+        promises: {
+            readFile: jest.fn(),
+            writeFile: jest.fn(),
+            readdir: jest.fn(),
+            mkdir: jest.fn(),
+            access: jest.fn(),
+            stat: jest.fn(),
+        },
+    };
+});
+jest.mock("axios", function () {
+    return {
+        default: {
+            create: jest.fn(function () {
+                return { get: jest.fn().mockResolvedValue({ data: { result: null } }) };
+            }),
+        },
+    };
+});
+// --- Imports ---
+const fs_1 = __importDefault(require("fs"));
+const ConfigManager = __importStar(require("../config"));
+const FileUtils_1 = require("../FileUtils");
+const appUtils_1 = require("../appUtils");
+const MultiScopeWatcher_1 = require("../MultiScopeWatcher");
+// --- Fixtures ---
+var makeFileContext = function (overrides) {
+    return Object.assign({
+        filePath: "/project/src/x_test_core/sys_script_include/TestScript/script.js",
+        ext: ".js",
+        sys_id: "abc123",
+        name: "TestScript",
+        scope: "x_test_core",
+        tableName: "sys_script_include",
+        targetField: "script",
+    }, overrides || {});
+};
+var TWO_SCOPES_CONFIG = {
+    sourceDirectory: "src",
+    buildDirectory: "build",
+    rules: [],
+    includes: {},
+    excludes: {},
+    tableOptions: {},
+    refreshInterval: 30,
+    scopes: {
+        x_scope_a: { sourceDirectory: "src/x_scope_a" },
+        x_scope_b: { sourceDirectory: "src/x_scope_b" },
+    },
+};
+// --- Tests ---
+describe("US-014: Global debounce for serialized scope processing", function () {
+    beforeEach(function () {
+        jest.clearAllMocks();
+        mockWatchers.length = 0;
+        capturedDebounceFns.length = 0;
+        (0, MultiScopeWatcher_1.stopMultiScopeWatching)();
+        MultiScopeWatcher_1.multiScopeWatcher.cachedScope = null;
+        MultiScopeWatcher_1.multiScopeWatcher.cachedUserSysId = null;
+        MultiScopeWatcher_1.multiScopeWatcher.pendingScopes = new Map();
+        MultiScopeWatcher_1.multiScopeWatcher.globalProcessQueue = null;
+        // Default scope switching succeeds
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
+        mockSNClient.getUserSysId.mockResolvedValue([{ sys_id: "user_sys_id" }]);
+        mockSNClient.getCurrentAppUserPrefSysId.mockResolvedValue([{ sys_id: "pref_sys_id" }]);
+        mockSNClient.updateCurrentAppUserPref.mockResolvedValue({});
+        mockSNClient.createCurrentAppUserPref.mockResolvedValue({});
+        fs_1.default.existsSync.mockReturnValue(false);
+    });
+    afterEach(function () {
+        (0, MultiScopeWatcher_1.stopMultiScopeWatching)();
+        jest.useRealTimers();
+    });
+    it("creates a single global debounce, not one per scope", async function () {
+        ConfigManager.getConfig.mockReturnValue(TWO_SCOPES_CONFIG);
+        await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 0 });
+        // Two scopes but only one debounce function captured
+        expect(capturedDebounceFns.length).toBe(1);
+    });
+    it("processes multiple scopes triggered within debounce window in a single batch", async function () {
+        ConfigManager.getConfig.mockReturnValue(TWO_SCOPES_CONFIG);
+        var ctxA = makeFileContext({ scope: "x_scope_a", filePath: "/project/src/x_scope_a/sys_script_include/A/script.js" });
+        var ctxB = makeFileContext({ scope: "x_scope_b", filePath: "/project/src/x_scope_b/sys_script_include/B/script.js" });
+        FileUtils_1.getFileContextWithSkipReason.mockImplementation(function (fp) {
+            if (fp.indexOf("x_scope_a") !== -1)
+                return { context: ctxA };
+            if (fp.indexOf("x_scope_b") !== -1)
+                return { context: ctxB };
+            return { skipReason: "unknown" };
+        });
+        appUtils_1.groupAppFiles.mockReturnValue([{ table: "sys_script_include", sysId: "abc123", fields: {} }]);
+        appUtils_1.pushFiles.mockResolvedValue([{ success: true, message: "ok" }]);
+        await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 0 });
+        // Emit changes in both scopes before debounce fires
+        mockWatchers[0]._emit("change", ctxA.filePath);
+        mockWatchers[1]._emit("change", ctxB.filePath);
+        // Fire the single global debounce
+        await capturedDebounceFns[0]();
+        // Both scopes should have been processed (pushFiles called twice — once per scope)
+        expect(appUtils_1.pushFiles).toHaveBeenCalledTimes(2);
+    });
+    it("processes scopes in FIFO order by first file change timestamp", async function () {
+        ConfigManager.getConfig.mockReturnValue(TWO_SCOPES_CONFIG);
+        var ctxA = makeFileContext({ scope: "x_scope_a", filePath: "/project/src/x_scope_a/sys_script_include/A/script.js" });
+        var ctxB = makeFileContext({ scope: "x_scope_b", filePath: "/project/src/x_scope_b/sys_script_include/B/script.js" });
+        FileUtils_1.getFileContextWithSkipReason.mockImplementation(function (fp) {
+            if (fp.indexOf("x_scope_a") !== -1)
+                return { context: ctxA };
+            if (fp.indexOf("x_scope_b") !== -1)
+                return { context: ctxB };
+            return { skipReason: "unknown" };
+        });
+        appUtils_1.groupAppFiles.mockReturnValue([{ table: "sys_script_include", sysId: "abc123", fields: {} }]);
+        appUtils_1.pushFiles.mockResolvedValue([{ success: true, message: "ok" }]);
+        await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 0 });
+        // Scope B changes first, then scope A
+        // Use pendingScopes directly to control timestamps for deterministic ordering
+        MultiScopeWatcher_1.multiScopeWatcher.pendingScopes.set("x_scope_b", 1000);
+        MultiScopeWatcher_1.multiScopeWatcher.pendingScopes.set("x_scope_a", 2000);
+        // Add files to queues manually
+        var watcherA = MultiScopeWatcher_1.multiScopeWatcher.scopeWatchers.get("x_scope_a");
+        var watcherB = MultiScopeWatcher_1.multiScopeWatcher.scopeWatchers.get("x_scope_b");
+        watcherA.pushQueue.push(ctxA.filePath);
+        watcherB.pushQueue.push(ctxB.filePath);
+        // Track the order of scope switches
+        var switchOrder = [];
+        mockSNClient.getScopeId.mockImplementation(function (scope) {
+            switchOrder.push(scope);
+            return Promise.resolve([{ sys_id: "scope_sys_id_" + scope }]);
+        });
+        // Fire the global debounce
+        await capturedDebounceFns[0]();
+        // Scope B (timestamp 1000) should be processed before scope A (timestamp 2000)
+        expect(switchOrder[0]).toBe("x_scope_b");
+        expect(switchOrder[1]).toBe("x_scope_a");
+    });
+    it("clears pendingScopes after processing", async function () {
+        ConfigManager.getConfig.mockReturnValue(TWO_SCOPES_CONFIG);
+        var ctx = makeFileContext({ scope: "x_scope_a", filePath: "/project/src/x_scope_a/sys_script_include/A/script.js" });
+        FileUtils_1.getFileContextWithSkipReason.mockReturnValue({ context: ctx });
+        appUtils_1.groupAppFiles.mockReturnValue([{ table: "sys_script_include", sysId: "abc123", fields: {} }]);
+        appUtils_1.pushFiles.mockResolvedValue([{ success: true, message: "ok" }]);
+        await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 0 });
+        mockWatchers[0]._emit("change", ctx.filePath);
+        await capturedDebounceFns[0]();
+        expect(MultiScopeWatcher_1.multiScopeWatcher.pendingScopes.size).toBe(0);
+    });
+    it("only records first change timestamp per scope (not subsequent changes)", async function () {
+        ConfigManager.getConfig.mockReturnValue({
+            ...TWO_SCOPES_CONFIG,
+            scopes: { x_scope_a: { sourceDirectory: "src/x_scope_a" } },
+        });
+        await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 0 });
+        // Record the timestamp after first emit
+        mockWatchers[0]._emit("change", "/project/src/x_scope_a/sys_script_include/A/script.js");
+        var firstTimestamp = MultiScopeWatcher_1.multiScopeWatcher.pendingScopes.get("x_scope_a");
+        // Wait a bit and emit again
+        await new Promise(function (r) { setTimeout(r, 5); });
+        mockWatchers[0]._emit("change", "/project/src/x_scope_a/sys_script_include/B/script.js");
+        var secondTimestamp = MultiScopeWatcher_1.multiScopeWatcher.pendingScopes.get("x_scope_a");
+        // Timestamp should not have changed
+        expect(secondTimestamp).toBe(firstTimestamp);
+    });
+});

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

@@ -61,7 +61,7 @@ jest.mock("chokidar", () => ({
         return w;
     }),
 }));
-// Debounce: capture per-scope processors, tests trigger manually
+// Debounce: capture the global processor, tests trigger manually
 const capturedDebounceFns = [];
 jest.mock("lodash", () => {
     const actual = jest.requireActual("lodash");
@@ -90,6 +90,7 @@ jest.mock("../snClient", () => ({
 }));
 jest.mock("../FileUtils", () => ({
     getFileContextFromPath: jest.fn(),
+    getFileContextWithSkipReason: jest.fn(),
 }));
 jest.mock("../appUtils", () => ({
     groupAppFiles: jest.fn(),
@@ -98,6 +99,9 @@ jest.mock("../appUtils", () => ({
 jest.mock("../logMessages", () => ({
     logFilePush: jest.fn(),
 }));
+jest.mock("../recentEdits", () => ({
+    writeRecentEdit: jest.fn(),
+}));
 jest.mock("../Logger", () => ({
     logger: {
         info: jest.fn(),
@@ -118,9 +122,11 @@ jest.mock("../config", () => ({
     getScopeManifestPath: jest.fn((scope) => `/project/sinc.manifest.${scope}.json`),
     getManifestPath: jest.fn().mockReturnValue("/project/sinc.manifest.json"),
 }));
-// Mock fs for manifest loading (dynamic import in MultiScopeWatcher)
+// Mock fs for manifest loading and config file access
 jest.mock("fs", () => ({
     existsSync: jest.fn(),
+    readFileSync: jest.fn(),
+    writeFileSync: jest.fn(),
     promises: {
         readFile: jest.fn(),
         writeFile: jest.fn(),
@@ -189,6 +195,12 @@ describe("MultiScopeWatcherManager", () => {
         capturedDebounceFns.length = 0;
         // Reset the internal state by stopping any previous watchers
         (0, MultiScopeWatcher_1.stopMultiScopeWatching)();
+        // Reset scope and user caches (US-013)
+        MultiScopeWatcher_1.multiScopeWatcher.cachedScope = null;
+        MultiScopeWatcher_1.multiScopeWatcher.cachedUserSysId = null;
+        // Reset global debounce state (US-014)
+        MultiScopeWatcher_1.multiScopeWatcher.pendingScopes = new Map();
+        MultiScopeWatcher_1.multiScopeWatcher.globalProcessQueue = null;
         // Default: scope switching succeeds
         mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
         mockSNClient.getUserSysId.mockResolvedValue([{ sys_id: "user_sys_id" }]);
@@ -265,20 +277,20 @@ describe("MultiScopeWatcherManager", () => {
         });
         it("processes file change through scope switch and push pipeline", async () => {
             const ctx = makeFileContext();
-            FileUtils_1.getFileContextFromPath.mockReturnValue(ctx);
+            FileUtils_1.getFileContextWithSkipReason.mockReturnValue({ context: ctx });
             appUtils_1.groupAppFiles.mockReturnValue([{ table: "sys_script_include", sysId: "abc123", fields: {} }]);
             appUtils_1.pushFiles.mockResolvedValue([{ success: true, message: "ok" }]);
             // Emit change on the scope's watcher
             mockWatchers[0]._emit("change", ctx.filePath);
             // Trigger the debounced processor for this scope
             await capturedDebounceFns[0]();
-            expect(FileUtils_1.getFileContextFromPath).toHaveBeenCalled();
+            expect(FileUtils_1.getFileContextWithSkipReason).toHaveBeenCalled();
             expect(appUtils_1.groupAppFiles).toHaveBeenCalled();
             expect(appUtils_1.pushFiles).toHaveBeenCalled();
         });
         it("processes file add through the same pipeline", async () => {
             const ctx = makeFileContext();
-            FileUtils_1.getFileContextFromPath.mockReturnValue(ctx);
+            FileUtils_1.getFileContextWithSkipReason.mockReturnValue({ context: ctx });
             appUtils_1.groupAppFiles.mockReturnValue([{ table: "sys_script_include", sysId: "abc123", fields: {} }]);
             appUtils_1.pushFiles.mockResolvedValue([{ success: true, message: "ok" }]);
             mockWatchers[0]._emit("add", ctx.filePath);
@@ -286,12 +298,102 @@ describe("MultiScopeWatcherManager", () => {
             expect(appUtils_1.pushFiles).toHaveBeenCalled();
         });
         it("warns when no valid file contexts found", async () => {
-            FileUtils_1.getFileContextFromPath.mockReturnValue(undefined);
+            FileUtils_1.getFileContextWithSkipReason.mockReturnValue({ skipReason: "not in manifest" });
             mockWatchers[0]._emit("change", "/project/src/x_test_core/unknown/file.txt");
             await capturedDebounceFns[0]();
             expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("No valid file contexts found"));
             expect(appUtils_1.pushFiles).not.toHaveBeenCalled();
         });
+        it("logs warning for each skipped file with reason", async () => {
+            FileUtils_1.getFileContextWithSkipReason
+                .mockReturnValueOnce({ skipReason: "not in manifest" })
+                .mockReturnValueOnce({ context: makeFileContext() });
+            appUtils_1.groupAppFiles.mockReturnValue([{ table: "sys_script_include", sysId: "abc123", fields: {} }]);
+            appUtils_1.pushFiles.mockResolvedValue([{ success: true, message: "ok" }]);
+            mockWatchers[0]._emit("change", "/project/src/x_test_core/unknown/file.txt");
+            mockWatchers[0]._emit("change", makeFileContext().filePath);
+            await capturedDebounceFns[0]();
+            expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("Skipped: /project/src/x_test_core/unknown/file.txt (not in manifest)"));
+        });
+        it("logs warning with scope not found reason", async () => {
+            FileUtils_1.getFileContextWithSkipReason.mockReturnValue({ skipReason: "scope not found" });
+            mockWatchers[0]._emit("change", "/project/src/x_unknown/sys_script/file.js");
+            await capturedDebounceFns[0]();
+            expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("Skipped: /project/src/x_unknown/sys_script/file.js (scope not found)"));
+        });
+        it("logs push summary with skipped file count", async () => {
+            var ctx = makeFileContext();
+            FileUtils_1.getFileContextWithSkipReason
+                .mockReturnValueOnce({ context: ctx })
+                .mockReturnValueOnce({ skipReason: "not in manifest" });
+            appUtils_1.groupAppFiles.mockReturnValue([{ table: "sys_script_include", sysId: "abc123", fields: {} }]);
+            appUtils_1.pushFiles.mockResolvedValue([{ success: true, message: "ok" }]);
+            mockWatchers[0]._emit("change", ctx.filePath);
+            mockWatchers[0]._emit("change", "/project/src/x_test_core/unknown/other.txt");
+            await capturedDebounceFns[0]();
+            // Should log a summary with pushed/total counts and skipped files
+            var allCalls = [
+                ...Logger_1.logger.info.mock.calls,
+                ...Logger_1.logger.success.mock.calls,
+            ].map(function (c) { return c[0]; });
+            var summaryCall = allCalls.find(function (msg) {
+                return typeof msg === "string" && msg.indexOf("Pushed") !== -1 && msg.indexOf("files to") !== -1;
+            });
+            expect(summaryCall).toBeDefined();
+            expect(summaryCall).toContain("1/2");
+            expect(summaryCall).toContain("skipped");
+        });
+        it("allows file through when scope matches watcher scope", async () => {
+            const ctx = makeFileContext({ scope: "x_test_core" });
+            FileUtils_1.getFileContextWithSkipReason.mockReturnValue({ context: ctx });
+            appUtils_1.groupAppFiles.mockReturnValue([{ table: "sys_script_include", sysId: "abc123", fields: {} }]);
+            appUtils_1.pushFiles.mockResolvedValue([{ success: true, message: "ok" }]);
+            mockWatchers[0]._emit("change", ctx.filePath);
+            await capturedDebounceFns[0]();
+            expect(appUtils_1.pushFiles).toHaveBeenCalled();
+            expect(Logger_1.logger.error).not.toHaveBeenCalledWith(expect.stringContaining("Scope mismatch"));
+        });
+        it("skips file with error when scope mismatches watcher scope", async () => {
+            const ctx = makeFileContext({ scope: "x_other_scope" });
+            FileUtils_1.getFileContextWithSkipReason.mockReturnValue({ context: ctx });
+            mockWatchers[0]._emit("change", ctx.filePath);
+            await capturedDebounceFns[0]();
+            // Should log an error about scope mismatch
+            expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("Scope mismatch"));
+            expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("x_other_scope"));
+            expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("x_test_core"));
+            // Should not push the file
+            expect(appUtils_1.pushFiles).not.toHaveBeenCalled();
+            // Should appear in the summary as skipped
+            expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("No valid file contexts found"));
+        });
+        it("includes scope-mismatched file in push summary alongside valid files", async () => {
+            const validCtx = makeFileContext({ scope: "x_test_core", filePath: "/project/src/x_test_core/sys_script_include/Valid/script.js" });
+            const mismatchCtx = makeFileContext({ scope: "x_other_scope", filePath: "/project/src/x_test_core/sys_script_include/Wrong/script.js" });
+            FileUtils_1.getFileContextWithSkipReason
+                .mockReturnValueOnce({ context: validCtx })
+                .mockReturnValueOnce({ context: mismatchCtx });
+            appUtils_1.groupAppFiles.mockReturnValue([{ table: "sys_script_include", sysId: "abc123", fields: {} }]);
+            appUtils_1.pushFiles.mockResolvedValue([{ success: true, message: "ok" }]);
+            mockWatchers[0]._emit("change", validCtx.filePath);
+            mockWatchers[0]._emit("change", mismatchCtx.filePath);
+            await capturedDebounceFns[0]();
+            // Valid file should be pushed
+            expect(appUtils_1.pushFiles).toHaveBeenCalled();
+            // Mismatch should be logged as error
+            expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("Scope mismatch"));
+            // Push summary should include the skipped file
+            var allCalls = [
+                ...Logger_1.logger.info.mock.calls,
+                ...Logger_1.logger.success.mock.calls,
+            ].map(function (c) { return c[0]; });
+            var summaryCall = allCalls.find(function (msg) {
+                return typeof msg === "string" && msg.indexOf("Pushed") !== -1 && msg.indexOf("files to") !== -1;
+            });
+            expect(summaryCall).toBeDefined();
+            expect(summaryCall).toContain("1/2");
+            expect(summaryCall).toContain("skipped");
+        });
         it("logs error on watcher error event", () => {
             mockWatchers[0]._emit("error", new Error("FS error"));
             expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("Watcher error: FS error"));
@@ -437,7 +539,7 @@ describe("MultiScopeWatcherManager", () => {
         });
     });
     describe("update set monitoring", () => {
-        it("sets up a 2-minute interval via setInterval", async () => {
+        it("sets up interval with default 120s when no options provided", async () => {
             const setIntervalSpy = jest.spyOn(global, "setInterval");
             ConfigManager.getConfig.mockReturnValue({
                 ...MOCK_CONFIG_TWO_SCOPES,

package/dist/tests/pushFiles.test.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Track how many times the update set config file is read
+var configReadCount = 0;
+var mockConfigData = {};
+jest.mock("fs", function () {
+    var actualFs = jest.requireActual("fs");
+    return {
+        ...actualFs,
+        existsSync: function (p) {
+            if (typeof p === "string" && p.endsWith(".sinc-update-sets.json")) {
+                configReadCount++;
+                return Object.keys(mockConfigData).length > 0;
+            }
+            return actualFs.existsSync(p);
+        },
+        readFileSync: function (p, encoding) {
+            if (typeof p === "string" && p.endsWith(".sinc-update-sets.json")) {
+                return JSON.stringify(mockConfigData);
+            }
+            return actualFs.readFileSync(p, encoding);
+        },
+    };
+});
+// Mock dependencies that pushFiles needs
+var mockPushWithUpdateSet = jest.fn().mockResolvedValue({
+    data: { result: { status: "success" } },
+});
+var mockUpdateRecord = jest.fn().mockResolvedValue({
+    data: { result: { status: "success" } },
+});
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: function () {
+            return {
+                pushWithUpdateSet: mockPushWithUpdateSet,
+                updateRecord: mockUpdateRecord,
+            };
+        },
+        processPushResponse: function (_res, summary) {
+            return { success: true, message: summary };
+        },
+        retryOnErr: function (fn) {
+            return fn();
+        },
+        retryOnHttpErr: function (fn) {
+            return fn();
+        },
+        unwrapSNResponse: jest.fn(),
+        unwrapTableAPIFirstItem: jest.fn(),
+        SNClient: jest.fn(),
+    };
+});
+jest.mock("../PluginManager", function () {
+    return {
+        __esModule: true,
+        default: {
+            getFinalFileContents: function (ctx) {
+                return Promise.resolve("built-content");
+            },
+        },
+    };
+});
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            info: jest.fn(),
+            debug: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn(),
+            getLogLevel: function () { return "debug"; },
+        },
+    };
+});
+jest.mock("progress", function () {
+    return jest.fn().mockImplementation(function () {
+        return { tick: jest.fn() };
+    });
+});
+function makeRecord(table, sysId, scope) {
+    return {
+        table: table,
+        sysId: sysId,
+        fields: {
+            script: {
+                name: "TestRecord",
+                tableName: table,
+                targetField: "script",
+                ext: "js",
+                sys_id: sysId,
+                filePath: "/fake/path/script.js",
+                scope: scope,
+            },
+        },
+    };
+}
+describe("pushFiles", function () {
+    beforeEach(function () {
+        configReadCount = 0;
+        mockConfigData = {};
+        mockPushWithUpdateSet.mockClear();
+        mockUpdateRecord.mockClear();
+    });
+    it("reads update set config once at batch start, not per record", async function () {
+        // Set up config for two scopes
+        mockConfigData = {
+            "x_cadso_core": { sys_id: "us-core-123", name: "Core US" },
+            "x_cadso_work": { sys_id: "us-work-456", name: "Work US" },
+        };
+        var { pushFiles } = require("../appUtils");
+        var records = [
+            makeRecord("sys_script_include", "rec1", "x_cadso_core"),
+            makeRecord("sys_script_include", "rec2", "x_cadso_work"),
+            makeRecord("sys_script_include", "rec3", "x_cadso_core"),
+        ];
+        await pushFiles(records);
+        // Config should be read exactly once (existsSync check at batch start)
+        // not 3 times (once per record)
+        expect(configReadCount).toBe(1);
+    });
+    it("does not re-read config mid-batch even with multiple scopes", async function () {
+        mockConfigData = {
+            "x_cadso_core": { sys_id: "us-core-123", name: "Core US" },
+        };
+        var { pushFiles } = require("../appUtils");
+        var records = [
+            makeRecord("sys_script_include", "rec1", "x_cadso_core"),
+            makeRecord("sys_script_include", "rec2", "x_cadso_core"),
+        ];
+        await pushFiles(records);
+        // Only 1 read regardless of record count
+        expect(configReadCount).toBe(1);
+    });
+    it("routes records to correct update sets from cached config", async function () {
+        mockConfigData = {
+            "x_cadso_core": { sys_id: "us-core-123", name: "Core US" },
+            "x_cadso_work": { sys_id: "us-work-456", name: "Work US" },
+        };
+        var { pushFiles } = require("../appUtils");
+        var records = [
+            makeRecord("sys_script_include", "rec1", "x_cadso_core"),
+            makeRecord("sys_script_include", "rec2", "x_cadso_work"),
+        ];
+        await pushFiles(records);
+        // Both should use pushWithUpdateSet with their respective update set IDs
+        expect(mockPushWithUpdateSet).toHaveBeenCalledTimes(2);
+        var calls = mockPushWithUpdateSet.mock.calls;
+        var updateSetIds = calls.map(function (call) { return call[0]; });
+        expect(updateSetIds).toContain("us-core-123");
+        expect(updateSetIds).toContain("us-work-456");
+    });
+    it("uses updateRecord when no update set config exists", async function () {
+        mockConfigData = {};
+        var { pushFiles } = require("../appUtils");
+        var records = [
+            makeRecord("sys_script_include", "rec1", "x_cadso_core"),
+        ];
+        await pushFiles(records);
+        expect(mockUpdateRecord).toHaveBeenCalledTimes(1);
+        expect(mockPushWithUpdateSet).not.toHaveBeenCalled();
+    });
+});