@tenonhq/dovetail-core 0.0.85

package/dist/tests/taskClear.test.js

@@ -0,0 +1,170 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_1 = require("../commands");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Mock logger
+var logMessages = [];
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            setLogLevel: jest.fn(),
+            success: jest.fn(function (msg) {
+                logMessages.push({ level: "success", msg: msg });
+            }),
+            info: jest.fn(function (msg) {
+                logMessages.push({ level: "info", msg: msg });
+            }),
+            error: jest.fn(function (msg) {
+                logMessages.push({ level: "error", msg: msg });
+            }),
+            warn: jest.fn(function (msg) {
+                logMessages.push({ level: "warn", msg: msg });
+            }),
+            debug: jest.fn(),
+            getInternalLogger: jest.fn(function () {
+                return { error: jest.fn() };
+            }),
+        },
+    };
+});
+// Mock fs
+jest.mock("fs");
+var mockFs = fs;
+// Mock other imports to prevent side effects
+jest.mock("../config", function () {
+    return {
+        getConfig: jest.fn(function () { return {}; }),
+        loadConfigs: jest.fn(),
+    };
+});
+jest.mock("../appUtils", function () { return {}; });
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: jest.fn(),
+        unwrapSNResponse: jest.fn(),
+    };
+});
+jest.mock("../FileLogger", function () {
+    return { fileLogger: { debug: jest.fn() } };
+});
+jest.mock("../logMessages", function () {
+    return {
+        logPushResults: jest.fn(),
+        logBuildResults: jest.fn(),
+    };
+});
+jest.mock("../gitUtils", function () {
+    return { gitDiffToEncodedPaths: jest.fn() };
+});
+jest.mock("../FileUtils", function () {
+    return { encodedPathsToFilePaths: jest.fn() };
+});
+jest.mock("inquirer", function () {
+    return { prompt: jest.fn() };
+});
+describe("taskClearCommand", function () {
+    var taskPath;
+    var defaultArgs = { logLevel: "info" };
+    beforeEach(function () {
+        logMessages = [];
+        taskPath = path.resolve(process.cwd(), ".dove-active-task.json");
+        jest.clearAllMocks();
+    });
+    it("should remove .dove-active-task.json when it exists", async function () {
+        var taskData = JSON.stringify({
+            taskId: "abc123",
+            taskName: "My Test Task",
+            updateSetName: "CU-abc123",
+        });
+        mockFs.existsSync.mockImplementation(function (p) {
+            return p === taskPath;
+        });
+        mockFs.readFileSync.mockImplementation(function (p) {
+            if (p === taskPath)
+                return taskData;
+            throw new Error("file not found");
+        });
+        mockFs.unlinkSync.mockImplementation(function () { });
+        await (0, commands_1.taskClearCommand)(defaultArgs);
+        expect(mockFs.unlinkSync).toHaveBeenCalledWith(taskPath);
+        expect(logMessages.some(function (m) {
+            return m.level === "success" && m.msg.indexOf("My Test Task") !== -1;
+        })).toBe(true);
+    });
+    it("should show informational message when no active task exists", async function () {
+        mockFs.existsSync.mockReturnValue(false);
+        await (0, commands_1.taskClearCommand)(defaultArgs);
+        expect(mockFs.unlinkSync).not.toHaveBeenCalled();
+        expect(logMessages.some(function (m) {
+            return m.level === "info" && m.msg.indexOf("No active task") !== -1;
+        })).toBe(true);
+    });
+    it("should still remove file even if JSON is invalid", async function () {
+        mockFs.existsSync.mockImplementation(function (p) {
+            return p === taskPath;
+        });
+        mockFs.readFileSync.mockImplementation(function () {
+            return "not valid json";
+        });
+        mockFs.unlinkSync.mockImplementation(function () { });
+        await (0, commands_1.taskClearCommand)(defaultArgs);
+        expect(mockFs.unlinkSync).toHaveBeenCalledWith(taskPath);
+        expect(logMessages.some(function (m) {
+            return m.level === "success" && m.msg.indexOf("removed") !== -1;
+        })).toBe(true);
+    });
+    it("should use taskId as fallback when taskName is missing", async function () {
+        var taskData = JSON.stringify({
+            taskId: "def456",
+            updateSetName: "CU-def456",
+        });
+        mockFs.existsSync.mockImplementation(function (p) {
+            return p === taskPath;
+        });
+        mockFs.readFileSync.mockImplementation(function (p) {
+            if (p === taskPath)
+                return taskData;
+            throw new Error("file not found");
+        });
+        mockFs.unlinkSync.mockImplementation(function () { });
+        await (0, commands_1.taskClearCommand)(defaultArgs);
+        expect(mockFs.unlinkSync).toHaveBeenCalledWith(taskPath);
+        expect(logMessages.some(function (m) {
+            return m.level === "success" && m.msg.indexOf("def456") !== -1;
+        })).toBe(true);
+    });
+});

package/dist/tests/taskStaleness.test.js

@@ -0,0 +1,220 @@
+"use strict";
+/**
+ * Tests for US-012: Add staleness warning for active task
+ *
+ * Validates:
+ * - On startup, if .dove-active-task.json is older than 7 days, a warning is logged
+ * - Fresh task files produce no warning
+ * - Warning includes task name and age in days
+ */
+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 });
+// --- Mock setup ---
+const mockSNClient = {
+    getScopeId: jest.fn(),
+    getUserSysId: jest.fn(),
+    getCurrentAppUserPrefSysId: jest.fn(),
+    updateCurrentAppUserPref: jest.fn(),
+    createCurrentAppUserPref: jest.fn(),
+    changeScope: jest.fn().mockResolvedValue(undefined),
+    createUpdateSet: jest.fn(),
+    changeUpdateSet: jest.fn(),
+    getCurrentUpdateSet: jest.fn(),
+    client: {
+        get: jest.fn(),
+    },
+};
+jest.mock("../snClient", () => ({
+    defaultClient: jest.fn(() => mockSNClient),
+    unwrapSNResponse: jest.fn((val) => val),
+}));
+jest.mock("../FileUtils", () => ({
+    getFileContextFromPath: jest.fn(),
+    getFileContextWithSkipReason: jest.fn(),
+}));
+jest.mock("../appUtils", () => ({
+    groupAppFiles: jest.fn(),
+    pushFiles: jest.fn(),
+}));
+jest.mock("../logMessages", () => ({
+    logFilePush: jest.fn(),
+}));
+jest.mock("../recentEdits", () => ({
+    writeRecentEdit: jest.fn(),
+}));
+jest.mock("../Logger", () => ({
+    logger: {
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        success: jest.fn(),
+        getLogLevel: jest.fn().mockReturnValue("info"),
+    },
+}));
+jest.mock("../config", () => ({
+    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((scope) => `/project/dove.manifest.${scope}.json`),
+    getManifestPath: jest.fn().mockReturnValue("/project/dove.manifest.json"),
+}));
+// Filesystem mock store
+var mockFsStore = {};
+var mockFsStatStore = {};
+jest.mock("fs", () => ({
+    existsSync: jest.fn((p) => {
+        return p in mockFsStore;
+    }),
+    readFileSync: jest.fn((p) => {
+        if (p in mockFsStore)
+            return mockFsStore[p];
+        throw new Error("ENOENT: " + p);
+    }),
+    writeFileSync: jest.fn((p, data) => {
+        mockFsStore[p] = data;
+    }),
+    statSync: jest.fn((p) => {
+        if (p in mockFsStatStore)
+            return mockFsStatStore[p];
+        return { mtimeMs: Date.now() };
+    }),
+    promises: {
+        readFile: jest.fn(),
+        writeFile: jest.fn(),
+        readdir: jest.fn(),
+        mkdir: jest.fn(),
+        access: jest.fn(),
+        stat: jest.fn(),
+    },
+}));
+jest.mock("chokidar", () => ({
+    watch: jest.fn(() => ({
+        on: jest.fn().mockReturnThis(),
+        close: jest.fn(),
+    })),
+}));
+jest.mock("lodash", () => {
+    var actual = jest.requireActual("lodash");
+    return {
+        ...actual,
+        debounce: jest.fn((fn) => {
+            var wrapper = jest.fn();
+            wrapper.cancel = jest.fn();
+            wrapper.flush = jest.fn(() => fn());
+            return wrapper;
+        }),
+    };
+});
+jest.mock("axios", () => ({
+    default: {
+        create: jest.fn(() => ({
+            get: jest.fn().mockResolvedValue({ data: { result: null } }),
+        })),
+    },
+}));
+// --- Imports ---
+const Logger_1 = require("../Logger");
+const MultiScopeWatcher_1 = require("../MultiScopeWatcher");
+const path = __importStar(require("path"));
+// --- Tests ---
+describe("US-012: Add staleness warning for active task", () => {
+    var taskPath;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFsStore = {};
+        mockFsStatStore = {};
+        taskPath = path.resolve(process.cwd(), ".dove-active-task.json");
+    });
+    it("should warn when active task file is older than 7 days", () => {
+        var validTask = {
+            taskId: "TASK-123",
+            taskName: "Old Feature",
+            updateSetName: "CU-TASK-123",
+        };
+        mockFsStore[taskPath] = JSON.stringify(validTask);
+        // 10 days ago
+        mockFsStatStore[taskPath] = { mtimeMs: Date.now() - (10 * 24 * 60 * 60 * 1000) };
+        var result = MultiScopeWatcher_1.multiScopeWatcher.readActiveTask();
+        expect(result).not.toBeNull();
+        expect(result.taskId).toBe("TASK-123");
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("Old Feature"));
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("10 days ago"));
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("dove task clear"));
+    });
+    it("should not warn when active task file is fresh (under 7 days)", () => {
+        var validTask = {
+            taskId: "TASK-456",
+            taskName: "Recent Feature",
+            updateSetName: "CU-TASK-456",
+        };
+        mockFsStore[taskPath] = JSON.stringify(validTask);
+        // 2 days ago
+        mockFsStatStore[taskPath] = { mtimeMs: Date.now() - (2 * 24 * 60 * 60 * 1000) };
+        var result = MultiScopeWatcher_1.multiScopeWatcher.readActiveTask();
+        expect(result).not.toBeNull();
+        expect(result.taskId).toBe("TASK-456");
+        expect(Logger_1.logger.warn).not.toHaveBeenCalled();
+    });
+    it("should use taskId as fallback when taskName is missing", () => {
+        var taskNoName = {
+            taskId: "TASK-789",
+            updateSetName: "CU-TASK-789",
+        };
+        mockFsStore[taskPath] = JSON.stringify(taskNoName);
+        // 14 days ago
+        mockFsStatStore[taskPath] = { mtimeMs: Date.now() - (14 * 24 * 60 * 60 * 1000) };
+        var result = MultiScopeWatcher_1.multiScopeWatcher.readActiveTask();
+        expect(result).not.toBeNull();
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("TASK-789"));
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("14 days ago"));
+    });
+    it("should not warn when task file is exactly 6 days old", () => {
+        var validTask = {
+            taskId: "TASK-EDGE",
+            taskName: "Edge Case",
+            updateSetName: "CU-TASK-EDGE",
+        };
+        mockFsStore[taskPath] = JSON.stringify(validTask);
+        // 6 days ago
+        mockFsStatStore[taskPath] = { mtimeMs: Date.now() - (6 * 24 * 60 * 60 * 1000) };
+        var result = MultiScopeWatcher_1.multiScopeWatcher.readActiveTask();
+        expect(result).not.toBeNull();
+        expect(Logger_1.logger.warn).not.toHaveBeenCalled();
+    });
+});

package/dist/tests/unwrapSNResponseError.test.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * Tests for the enhanced error path in unwrapSNResponse.
+ *
+ * When a ServiceNow REST call throws, the catch block must:
+ *  - Log a structured one-liner via logger.error including HTTP status, method, URL
+ *    and (when present) the ServiceNow-shaped error message from the response body.
+ *  - Dump the full error surface (status, statusText, responseData, responseHeaders,
+ *    scope extracted from /getManifest/:scope URLs) via fileLogger.debug.
+ *  - Re-throw the original error so upstream callers see identical behaviour.
+ *
+ * Non-Axios errors must preserve the original log shape ("Error from <instance>: <msg>")
+ * and also produce a debug dump for future triage.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var mockLogger = {
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    getLogLevel: function () { return "debug"; },
+};
+var mockFileLogger = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+};
+jest.mock("../Logger", function () {
+    return { logger: mockLogger };
+});
+jest.mock("../FileLogger", function () {
+    return { fileLogger: mockFileLogger };
+});
+const snClient_1 = require("../snClient");
+function makeAxiosError(overrides) {
+    var error = new Error("Request failed with status code " + overrides.status);
+    error.isAxiosError = true;
+    error.config = {
+        method: overrides.method || "post",
+        url: overrides.url || "api/sinc/sincronia/getManifest/x_cadso_example",
+    };
+    error.response = {
+        status: overrides.status,
+        statusText: overrides.statusText || "",
+        headers: overrides.headers || { "x-test": "1" },
+        data: overrides.data,
+    };
+    return error;
+}
+describe("unwrapSNResponse — error handling", function () {
+    var origInstance;
+    beforeAll(function () {
+        origInstance = process.env.SN_INSTANCE;
+        process.env.SN_INSTANCE = "tenontest.service-now.com";
+    });
+    afterAll(function () {
+        if (origInstance === undefined)
+            delete process.env.SN_INSTANCE;
+        else
+            process.env.SN_INSTANCE = origInstance;
+    });
+    beforeEach(function () {
+        jest.clearAllMocks();
+    });
+    test("Axios 500 with ServiceNow-shaped body: one-liner includes status + URL + SN message, debug dump carries full detail", async function () {
+        var snBody = {
+            error: {
+                message: "org.mozilla.javascript.EcmaError: TypeError",
+                detail: "Cannot read property 'name' of null",
+            },
+            status: "failure",
+        };
+        var axErr = makeAxiosError({
+            status: 500,
+            method: "post",
+            url: "api/sinc/sincronia/getManifest/x_cadso_automate",
+            data: snBody,
+            statusText: "Internal Server Error",
+        });
+        var rejected = Promise.reject(axErr);
+        // Silence the unhandled-rejection warning before jest inspects it
+        rejected.catch(function () { });
+        await expect((0, snClient_1.unwrapSNResponse)(rejected)).rejects.toBe(axErr);
+        expect(mockLogger.error).toHaveBeenCalledTimes(1);
+        var userLine = mockLogger.error.mock.calls[0][0];
+        expect(userLine).toContain("tenontest.service-now.com");
+        expect(userLine).toContain("HTTP 500");
+        expect(userLine).toContain("POST");
+        expect(userLine).toContain("getManifest/x_cadso_automate");
+        expect(userLine).toContain("org.mozilla.javascript.EcmaError");
+        expect(mockFileLogger.debug).toHaveBeenCalledTimes(1);
+        var debugLabel = mockFileLogger.debug.mock.calls[0][0];
+        var debugPayload = mockFileLogger.debug.mock.calls[0][1];
+        expect(debugLabel).toBe("REST error detail");
+        expect(debugPayload).toMatchObject({
+            instance: "tenontest.service-now.com",
+            scope: "x_cadso_automate",
+            method: "POST",
+            status: 500,
+            statusText: "Internal Server Error",
+            responseData: snBody,
+            responseHeaders: { "x-test": "1" },
+        });
+        expect(debugPayload.url).toContain("getManifest/x_cadso_automate");
+    });
+    test("Axios 500 with non-SN body: one-liner falls back cleanly, no crash", async function () {
+        var axErr = makeAxiosError({
+            status: 500,
+            method: "get",
+            url: "api/now/table/sys_script_include",
+            data: "<html><body>Gateway error</body></html>",
+        });
+        var rejected = Promise.reject(axErr);
+        rejected.catch(function () { });
+        await expect((0, snClient_1.unwrapSNResponse)(rejected)).rejects.toBe(axErr);
+        var userLine = mockLogger.error.mock.calls[0][0];
+        expect(userLine).toContain("HTTP 500");
+        expect(userLine).toContain("GET");
+        expect(userLine).toContain("table/sys_script_include");
+        // No SN message to append; no em dash
+        expect(userLine).not.toContain(" — ");
+        expect(mockFileLogger.debug).toHaveBeenCalledTimes(1);
+        var debugPayload = mockFileLogger.debug.mock.calls[0][1];
+        // Non-manifest URL — scope should be undefined
+        expect(debugPayload.scope).toBeUndefined();
+        expect(debugPayload.responseData).toBe("<html><body>Gateway error</body></html>");
+    });
+    test("Non-Axios error: preserves legacy log shape and re-throws", async function () {
+        var nonAxios = new Error("socket hang up");
+        var rejected = Promise.reject(nonAxios);
+        rejected.catch(function () { });
+        await expect((0, snClient_1.unwrapSNResponse)(rejected)).rejects.toBe(nonAxios);
+        expect(mockLogger.error).toHaveBeenCalledTimes(1);
+        var userLine = mockLogger.error.mock.calls[0][0];
+        expect(userLine).toBe("Error from tenontest.service-now.com: socket hang up");
+        expect(mockFileLogger.debug).toHaveBeenCalledTimes(1);
+        var debugLabel = mockFileLogger.debug.mock.calls[0][0];
+        expect(debugLabel).toBe("Non-Axios error detail");
+        var debugPayload = mockFileLogger.debug.mock.calls[0][1];
+        expect(debugPayload.message).toBe("socket hang up");
+        expect(debugPayload.errorName).toBe("Error");
+        expect(typeof debugPayload.errorStack).toBe("string");
+    });
+});

package/dist/tests/v2Values.test.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zlib_1 = require("zlib");
+const values_1 = require("../flowDesigner/values");
+describe("decodeV2Values / encodeV2Values", () => {
+    describe("round-trip", () => {
+        it("decodes what encodeV2Values encoded (primitive array)", () => {
+            const original = [
+                { actionInstanceSysId: "abc", id: "1", name: "to", value: "user@example.com" },
+                { actionInstanceSysId: "abc", id: "2", name: "subject", value: "hi" },
+            ];
+            const blob = (0, values_1.encodeV2Values)(original);
+            expect((0, values_1.decodeV2Values)(blob)).toEqual(original);
+        });
+        it("decodes what encodeV2Values encoded (nested parameter objects)", () => {
+            const original = [
+                {
+                    actionInstanceSysId: "abc123",
+                    id: "input_a",
+                    name: "record",
+                    value: { table: "incident", sys_id: "xyz" },
+                    parameter: {
+                        type: "reference",
+                        labels: { en: "Record" },
+                        validation: { mandatory: true },
+                    },
+                },
+            ];
+            const blob = (0, values_1.encodeV2Values)(original);
+            expect((0, values_1.decodeV2Values)(blob)).toEqual(original);
+        });
+        it("handles empty array", () => {
+            expect((0, values_1.decodeV2Values)((0, values_1.encodeV2Values)([]))).toEqual([]);
+        });
+        it("handles large payloads without truncation", () => {
+            const big = Array.from({ length: 500 }, (_, i) => ({
+                id: String(i),
+                name: "field_" + i,
+                value: "x".repeat(200),
+            }));
+            expect((0, values_1.decodeV2Values)((0, values_1.encodeV2Values)(big))).toEqual(big);
+        });
+    });
+    describe("decode — input validation", () => {
+        it("throws on empty string", () => {
+            expect(() => (0, values_1.decodeV2Values)("")).toThrow(/non-empty string/);
+        });
+        it("throws on whitespace-only string", () => {
+            expect(() => (0, values_1.decodeV2Values)("   \n  ")).toThrow(/non-empty string/);
+        });
+        it("throws on non-string input", () => {
+            expect(() => (0, values_1.decodeV2Values)(null)).toThrow(/non-empty string/);
+            expect(() => (0, values_1.decodeV2Values)(undefined)).toThrow(/non-empty string/);
+            expect(() => (0, values_1.decodeV2Values)(123)).toThrow(/non-empty string/);
+        });
+        it("throws with a clear message on non-gzip base64 input", () => {
+            // Valid base64, but the decoded bytes are not gzip.
+            const notGzip = Buffer.from("hello world").toString("base64");
+            expect(() => (0, values_1.decodeV2Values)(notGzip)).toThrow(/decompression failed/);
+        });
+        it("throws on gzip of invalid JSON", () => {
+            const badJson = (0, zlib_1.gzipSync)(Buffer.from("{not valid json", "utf8")).toString("base64");
+            expect(() => (0, values_1.decodeV2Values)(badJson)).toThrow(/not valid JSON/);
+        });
+        it("tolerates trailing whitespace and newlines (common from file reads)", () => {
+            const blob = (0, values_1.encodeV2Values)([{ id: "1", value: "a" }]);
+            expect((0, values_1.decodeV2Values)(blob + "\n")).toEqual([{ id: "1", value: "a" }]);
+            expect((0, values_1.decodeV2Values)("  " + blob + "  ")).toEqual([{ id: "1", value: "a" }]);
+        });
+    });
+    describe("generic typing", () => {
+        it("preserves the caller's expected type", () => {
+            const blob = (0, values_1.encodeV2Values)([{ actionInstanceSysId: "a", id: "1" }]);
+            const decoded = (0, values_1.decodeV2Values)(blob);
+            expect(decoded[0].actionInstanceSysId).toBe("a");
+            expect(decoded[0].id).toBe("1");
+        });
+    });
+});