@tenonhq/dovetail-core 0.0.113 → 0.0.115

package/dist/tests/allScopesMetadata.test.js

@@ -0,0 +1,193 @@
+"use strict";
+/**
+ * Regression: the all-scopes writer must normalize metaData.json, exactly like
+ * the `refresh` path does.
+ *
+ * `processManifestForScope` (allScopesCommands.ts) is what `dove initScopes` and
+ * `dove watchAllScopes` write through. It used to `fsp.writeFile` every server
+ * file verbatim, so on that path metaData.json kept the server's raw payload:
+ *
+ *   - `_record_link` with the full `https://<instance>.service-now.com` host,
+ *     making the on-disk artifact instance-bound — re-pull from another instance
+ *     and every file rewrites;
+ *   - every field's live `display_value`, which is resolved server-side at pull
+ *     time, so renaming one referenced record re-churns every file pointing at
+ *     it (and timestamp display_values render in the *puller's* timezone, so two
+ *     developers churn each other);
+ *
+ * and when the server sent no metadata at all it wrote a stub stamped
+ * `_generatedAt: new Date().toISOString()` — a value that changed on every run,
+ * by construction.
+ *
+ * The result: records written here diffed against the same records written by
+ * `refresh`, and a pull that changed nothing still dirtied the tree. The writer
+ * now routes every file through the shared `stampMetadataContent` and writes a
+ * deterministic placeholder instead of the timestamp stub.
+ */
+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(),
+};
+jest.mock("../Logger", function () { return { logger: mockLogger }; });
+jest.mock("../FileLogger", function () { return { fileLogger: mockFileLogger }; });
+jest.mock("../config", function () { return {}; });
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: function () { return {}; },
+        unwrapSNResponse: function (p) { return Promise.resolve(p); },
+    };
+});
+jest.mock("../wizard", function () {
+    return { setupDotEnv: jest.fn(), getLoginInfo: jest.fn() };
+});
+jest.mock("../commands", function () { return { setLogLevel: jest.fn() }; });
+jest.mock("progress", function () {
+    return jest.fn().mockImplementation(function () {
+        return { tick: jest.fn() };
+    });
+});
+const AllScopes = __importStar(require("../allScopesCommands"));
+const appUtils_1 = require("../appUtils");
+// ---------- helpers ----------
+var tmpRoot;
+var SYS_ID = "24a3a804c3eb7250d4ddf1db05013165";
+var ISO_STAMP = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
+/** The metaData.json payload a real instance returns: absolute link, display_values. */
+function serverMetadata() {
+    return JSON.stringify({
+        name: { value: "UIFilterApiMS", display_value: "UIFilterApiMS" },
+        sys_updated_on: {
+            value: "2026-04-29 14:38:51",
+            // Rendered in the puller's local timezone — the churn source.
+            display_value: "2026-04-29 07:38:51",
+        },
+        sys_scope: {
+            value: "4e4449a5475c255085d19fd8036d43a0",
+            display_value: "Tenon Marketing Work Management",
+        },
+        _table: "sys_script_include",
+        _sys_id: SYS_ID,
+        _record_link: "https://tenonworkstudio.service-now.com/sys_script_include.do?sys_id=" + SYS_ID,
+        _localOnly: true,
+        _lastUpdatedOn: "2026-04-29 14:38:51",
+        _description: "Complete field metadata for record - DO NOT SYNC TO SERVICENOW",
+    });
+}
+function manifestWith(files) {
+    return {
+        tables: {
+            sys_script_include: {
+                records: {
+                    UIFilterApiMS: { name: "UIFilterApiMS", sys_id: SYS_ID, files: files },
+                },
+            },
+        },
+    };
+}
+function readRecordFile(name) {
+    return fs.readFileSync(path.join(tmpRoot, "sys_script_include", "UIFilterApiMS", name), "utf8");
+}
+describe("all-scopes writer — metaData.json is normalized, not written raw", function () {
+    beforeEach(function () {
+        jest.clearAllMocks();
+        tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "dove-allscopes-meta-"));
+    });
+    afterEach(function () {
+        try {
+            fs.rmSync(tmpRoot, { recursive: true, force: true });
+        }
+        catch (e) { }
+    });
+    test("strips the instance host from _record_link", async function () {
+        await AllScopes.processManifestForScope(manifestWith([{ name: "metaData", type: "json", content: serverMetadata() }]), tmpRoot, true);
+        var written = JSON.parse(readRecordFile("metaData.json"));
+        expect(written._record_link).toBe("/sys_script_include.do?sys_id=" + SYS_ID);
+        expect(readRecordFile("metaData.json")).not.toContain("service-now.com");
+    });
+    test("strips every display_value, keeping value", async function () {
+        await AllScopes.processManifestForScope(manifestWith([{ name: "metaData", type: "json", content: serverMetadata() }]), tmpRoot, true);
+        var raw = readRecordFile("metaData.json");
+        var written = JSON.parse(raw);
+        expect(raw).not.toContain("display_value");
+        expect(written.name).toEqual({ value: "UIFilterApiMS" });
+        expect(written.sys_updated_on).toEqual({ value: "2026-04-29 14:38:51" });
+        expect(written.sys_scope).toEqual({ value: "4e4449a5475c255085d19fd8036d43a0" });
+    });
+    test("drops _lastUpdatedOn and writes no wall-clock value", async function () {
+        await AllScopes.processManifestForScope(manifestWith([{ name: "metaData", type: "json", content: serverMetadata() }]), tmpRoot, true);
+        var raw = readRecordFile("metaData.json");
+        expect(JSON.parse(raw)._lastUpdatedOn).toBeUndefined();
+        expect(raw).not.toMatch(ISO_STAMP);
+    });
+    test("two runs over the same server payload produce identical bytes", async function () {
+        // The contract in one assertion: a pull that changed nothing changes nothing.
+        await AllScopes.processManifestForScope(manifestWith([{ name: "metaData", type: "json", content: serverMetadata() }]), tmpRoot, true);
+        var first = readRecordFile("metaData.json");
+        await AllScopes.processManifestForScope(manifestWith([{ name: "metaData", type: "json", content: serverMetadata() }]), tmpRoot, true);
+        expect(readRecordFile("metaData.json")).toBe(first);
+    });
+    test("writes the deterministic placeholder when the server sends no metadata", async function () {
+        await AllScopes.processManifestForScope(manifestWith([{ name: "script", type: "js", content: "// no metadata came back" }]), tmpRoot, true);
+        var raw = readRecordFile("metaData.json");
+        expect(raw).toBe(appUtils_1.EMPTY_METADATA_CONTENT);
+        // The old stub's two churn keys are gone.
+        expect(raw).not.toContain("_generatedAt");
+        expect(raw).not.toMatch(ISO_STAMP);
+    });
+    test("leaves regular field files untouched", async function () {
+        // stampMetadataContent must be a no-op on anything that isn't metaData.json.
+        await AllScopes.processManifestForScope(manifestWith([
+            { name: "script", type: "js", content: "var x = 1;\n" },
+            { name: "metaData", type: "json", content: serverMetadata() },
+        ]), tmpRoot, true);
+        expect(readRecordFile("script.js")).toBe("var x = 1;\n");
+    });
+});

package/dist/tests/stampMetadataContent.test.js

@@ -2,16 +2,23 @@
 // Tests for stampMetadataContent — the writer that finalizes each record's
 // metaData.json before it lands on disk.
 //
-// Two on-disk-stability concerns are covered:
-//   1. _lastUpdatedOn is sourced from the record's sys_updated_on (stable across
-//      re-pulls) rather than a fresh wall-clock stamp.
+// The contract is determinism: the same record must produce the same bytes on
+// any instance, from any machine, on every pull. Three on-disk-stability
+// concerns are covered:
+//   1. No generation-time value survives. `_lastUpdatedOn` is deleted outright —
+//      it duplicated sys_updated_on.value exactly, and its no-sys_updated_on
+//      branch stamped a wall-clock that rewrote the file on every pull.
 //   2. _record_link is rewritten to an instance-relative path. The CADSO metadata
 //      endpoint returns an absolute URL (https://<instance>.service-now.com/...);
 //      persisting the host makes the artifact instance-bound and dirties every
 //      file on a re-pull from a different instance. Stripping any *.service-now.com
 //      host keeps the diff to genuine schema changes.
+//   3. display_value is stripped — it is resolved live server-side, so renaming
+//      a referenced record re-churns every file pointing at it.
 Object.defineProperty(exports, "__esModule", { value: true });
 const appUtils_1 = require("../appUtils");
+// Matches an ISO-8601 wall-clock stamp (what `new Date().toISOString()` emits).
+const ISO_STAMP = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
 const metaFile = (content) => ({
     name: "metaData",
     type: "json",
@@ -46,13 +53,13 @@ describe("stampMetadataContent — _record_link host stripping", () => {
         const out = (0, appUtils_1.stampMetadataContent)(metaFile({ _record_link: null }));
         expect(parse(out)._record_link).toBeNull();
     });
-    it("still sources _lastUpdatedOn from sys_updated_on while stripping the host", () => {
+    it("strips the host while leaving the record's own sys_updated_on intact", () => {
         const out = (0, appUtils_1.stampMetadataContent)(metaFile({
             sys_updated_on: { value: "2025-08-21 17:09:02" },
             _record_link: "https://tenonworkstudio.service-now.com/incident.do?sys_id=1",
         }));
         const parsed = parse(out);
-        expect(parsed._lastUpdatedOn).toBe("2025-08-21 17:09:02");
+        expect(parsed.sys_updated_on).toEqual({ value: "2025-08-21 17:09:02" });
         expect(parsed._record_link).toBe("/incident.do?sys_id=1");
     });
     it("passes through non-metaData files verbatim", () => {
@@ -60,6 +67,57 @@ describe("stampMetadataContent — _record_link host stripping", () => {
         expect((0, appUtils_1.stampMetadataContent)(script)).toEqual(script);
     });
 });
+describe("stampMetadataContent — no generation-time values", () => {
+    it("never writes _lastUpdatedOn, even when sys_updated_on is present", () => {
+        const out = (0, appUtils_1.stampMetadataContent)(metaFile({ sys_updated_on: { value: "2025-08-21 17:09:02" } }));
+        expect(parse(out)._lastUpdatedOn).toBeUndefined();
+    });
+    it("deletes a pre-existing _lastUpdatedOn so a re-stamp settles legacy content", () => {
+        // A branch pulled before this change carries the key on disk. Re-stamping
+        // has to remove it, otherwise the stale value persists forever and the
+        // mirror never converges.
+        const out = (0, appUtils_1.stampMetadataContent)(metaFile({
+            sys_updated_on: { value: "2025-08-21 17:09:02" },
+            _lastUpdatedOn: "2025-08-21 17:09:02",
+            _record_link: "/incident.do?sys_id=1",
+        }));
+        const parsed = parse(out);
+        expect(parsed._lastUpdatedOn).toBeUndefined();
+        expect(parsed._record_link).toBe("/incident.do?sys_id=1");
+    });
+    it("emits no wall-clock stamp when sys_updated_on is absent", () => {
+        // The old fallback stamped new Date().toISOString() here, which is what
+        // made every pull dirty the record.
+        const out = (0, appUtils_1.stampMetadataContent)(metaFile({ name: { value: "no audit columns" } }));
+        expect(out.content).not.toMatch(ISO_STAMP);
+        expect(parse(out)._lastUpdatedOn).toBeUndefined();
+    });
+    it("writes the deterministic placeholder for empty content", () => {
+        const out = (0, appUtils_1.stampMetadataContent)({ name: "metaData", type: "json", content: "" });
+        expect(out.content).toBe(appUtils_1.EMPTY_METADATA_CONTENT);
+        expect(out.content).not.toMatch(ISO_STAMP);
+    });
+    it("produces identical bytes across repeated runs (the whole point)", () => {
+        const server = {
+            sys_updated_on: { value: "2025-08-21 17:09:02", display_value: "2025-08-21 10:09:02" },
+            action: { value: "abc", display_value: "Some Record Name" },
+            _record_link: "https://tenonworkstudio.service-now.com/incident.do?sys_id=1",
+            _lastUpdatedOn: "2025-08-21 17:09:02",
+        };
+        // Two independent pulls of an unchanged record, one re-stamp of the result.
+        const first = (0, appUtils_1.stampMetadataContent)(metaFile(server));
+        const second = (0, appUtils_1.stampMetadataContent)(metaFile(server));
+        const restamped = (0, appUtils_1.stampMetadataContent)(first);
+        expect(second.content).toBe(first.content);
+        expect(restamped.content).toBe(first.content);
+    });
+    it("leaves non-object JSON alone rather than throwing", () => {
+        const bare = { name: "metaData", type: "json", content: '"just a string"' };
+        expect((0, appUtils_1.stampMetadataContent)(bare)).toEqual(bare);
+        const arr = { name: "metaData", type: "json", content: "[1,2,3]" };
+        expect((0, appUtils_1.stampMetadataContent)(arr)).toEqual(arr);
+    });
+});
 describe("stampMetadataContent — display_value stripping", () => {
     it("drops display_value from field pairs, keeping value", () => {
         const out = (0, appUtils_1.stampMetadataContent)(metaFile({

package/dist/tests/syncManifestRecord.test.js

@@ -0,0 +1,234 @@
+"use strict";
+/**
+ * Tests for the single-record narrowing of syncManifest — the `record` option
+ * used by `dove create`'s post-create round-trip.
+ *
+ * Regression target: `dove create <table>` previously called syncManifest(scope)
+ * with no narrowing, which re-downloaded and rewrote EVERY record in the scope.
+ * Creating one record churned ~1,892 files in a scope like x_cadso_text_spoke.
+ * The fix scopes the file refresh to just the created record.
+ *
+ * These tests assert:
+ *   1. narrowManifestToRecord returns only the matching record, never mutating input
+ *   2. narrowManifestToRecord returns an empty table map when the record is absent
+ *   3. syncManifest({ record }) fetches + writes ONLY the target record's files
+ *   4. sibling records already on disk are left untouched (never re-fetched)
+ *   5. a record absent from the fetched manifest → warn, no fetch, no throw
+ */
+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/dove.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() };
+    });
+});
+// Stub writeScopeManifest so the test never writes a manifest file. Leave the
+// other FileUtils exports real 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"));
+// ---------- fixtures ----------
+// A three-record scope manifest, all in sys_script_include, matching the shape
+// client.getManifest returns (files carry name+type only; no content).
+function threeRecordManifest() {
+    return {
+        scope: "x_cadso_core",
+        tables: {
+            sys_script_include: {
+                records: {
+                    New: { name: "New", sys_id: "sysid_New", files: [{ name: "script", type: "js" }] },
+                    Sib1: { name: "Sib1", sys_id: "sysid_Sib1", files: [{ name: "script", type: "js" }] },
+                    Sib2: { name: "Sib2", sys_id: "sysid_Sib2", files: [{ name: "script", type: "js" }] },
+                },
+            },
+        },
+    };
+}
+var tmpRoot;
+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;
+    }
+}
+// ---------- pure helper ----------
+describe("narrowManifestToRecord", function () {
+    test("returns only the matching record and does NOT mutate the input", function () {
+        var manifest = threeRecordManifest();
+        var out = AppUtils.narrowManifestToRecord(manifest, "sys_script_include", "sysid_New");
+        // input untouched — all three records still present
+        expect(Object.keys(manifest.tables.sys_script_include.records).sort())
+            .toEqual(["New", "Sib1", "Sib2"]);
+        // output holds exactly the one record
+        expect(Object.keys(out.tables)).toEqual(["sys_script_include"]);
+        expect(Object.keys(out.tables.sys_script_include.records)).toEqual(["New"]);
+        expect(out.tables.sys_script_include.records.New.sys_id).toBe("sysid_New");
+    });
+    test("returns an empty table map when the sys_id is absent", function () {
+        var manifest = threeRecordManifest();
+        var out = AppUtils.narrowManifestToRecord(manifest, "sys_script_include", "sysid_Missing");
+        expect(Object.keys(out.tables)).toEqual([]);
+    });
+    test("returns an empty table map when the table is absent", function () {
+        var manifest = threeRecordManifest();
+        var out = AppUtils.narrowManifestToRecord(manifest, "sys_ui_action", "sysid_New");
+        expect(Object.keys(out.tables)).toEqual([]);
+    });
+});
+// ---------- syncManifest({ record }) ----------
+describe("syncManifest — single-record round-trip (dove create)", function () {
+    beforeEach(function () {
+        jest.clearAllMocks();
+        tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "sinc-record-test-"));
+        mockConfig.getSourcePathForScope.mockReturnValue(tmpRoot);
+        mockConfig.getSourcePath.mockReturnValue(tmpRoot);
+    });
+    afterEach(function () {
+        try {
+            fs.rmSync(tmpRoot, { recursive: true, force: true });
+        }
+        catch (e) { }
+    });
+    test("fetches + writes ONLY the target record; siblings are never re-fetched", async function () {
+        // A stale sibling file already on disk — it must be left exactly as-is.
+        writeLocal("Sib1", "script", "js", "STALE SIBLING — must not change");
+        mockClient.getManifest.mockResolvedValue(threeRecordManifest());
+        // getMissingFiles should be asked for the new record ONLY; return its content.
+        mockClient.getMissingFiles.mockResolvedValue({
+            sys_script_include: {
+                records: {
+                    New: {
+                        name: "New", sys_id: "sysid_New",
+                        files: [{ name: "script", type: "js", content: "// fresh created record" }],
+                    },
+                },
+            },
+        });
+        await AppUtils.syncManifest("x_cadso_core", {
+            record: { table: "sys_script_include", sysId: "sysid_New" },
+        });
+        // exactly one content fetch, scoped to the one record
+        expect(mockClient.getMissingFiles).toHaveBeenCalledTimes(1);
+        var missingArg = mockClient.getMissingFiles.mock.calls[0][0];
+        expect(Object.keys(missingArg.sys_script_include)).toEqual(["sysid_New"]);
+        // the new record landed
+        expect(readLocal("New", "script", "js")).toBe("// fresh created record");
+        // siblings untouched
+        expect(readLocal("Sib1", "script", "js")).toBe("STALE SIBLING — must not change");
+        expect(readLocal("Sib2", "script", "js")).toBeNull();
+    });
+    test("record absent from the fetched manifest → warn, no fetch, no throw", async function () {
+        mockClient.getManifest.mockResolvedValue(threeRecordManifest());
+        await AppUtils.syncManifest("x_cadso_core", {
+            record: { table: "sys_script_include", sysId: "sysid_DoesNotExist" },
+        });
+        // empty narrowed manifest → refreshAllFiles no-ops, so no content fetch
+        expect(mockClient.getMissingFiles).not.toHaveBeenCalled();
+        // and the user is told to run a full refresh
+        var warned = mockLogger.warn.mock.calls.some(function (c) {
+            return typeof c[0] === "string" && c[0].indexOf("sysid_DoesNotExist") !== -1;
+        });
+        expect(warned).toBe(true);
+    });
+});