@tenonhq/dovetail-core 0.0.116 → 0.0.117

package/dist/appUtils.js

@@ -60,24 +60,65 @@ const getUpdateSetConfig = () => (0, updateSetConfig_1.readUpdateSetConfig)();
 // (/<table>.do?sys_id=...) resolves against whatever instance the reader is on.
 // Matches any *.service-now.com host so the output is portable across instances.
 const stripRecordLinkHost = (link) => link.replace(/^https?:\/\/[^/]+\.service-now\.com/i, "");
-// Strip the derived `display_value` from every field pair, keeping only `value`.
-// A ServiceNow field is serialized as a { value, display_value } pair. The
-// display_value is the *current* display name of the field's value — for a
-// reference field, the referenced record's name, resolved live on the server at
-// pull time. That makes it non-deterministic on disk: rename a referenced record
-// on the instance and every metaData.json pointing at it re-churns its
-// display_value on the next pull, even though the pointing record is unchanged.
-// `value` (the sys_id / raw value) is the stable identity; display_value is a
-// convenience the mirror does not need. Reconcile already ignores metaData.json
-// content and pushes key off `value` / the manifest, so no consumer depends on
-// the persisted display_value. Dropping it keeps re-pulls byte-identical.
+// A ServiceNow field is serialized as a { value, display_value } pair, where
+// display_value is rendered live server-side at pull time. Some of those
+// renderings are worth persisting and some are pure churn, so this is a
+// selective drop rather than a blanket one — an earlier blanket strip threw away
+// the readable sys_id -> name mapping that `Documentation/Dovetail-Development.md`
+// documents grepping to walk the record graph.
+//
+// Measured over 43,990 pairs in the servicenow-files mirror:
+//
+//   DROPPED
+//     identical (62.1%, ~4.5 MB) — display_value === value carries zero
+//       information by construction, at any size. The heavy ones are the large
+//       text fields (script, props, label_cache, composition, operation_script):
+//       619 pairs, but ~3.7 MB of the total.
+//     datetime (3.9%) — `value` is UTC; `display_value` is rendered in the
+//       TIMEZONE OF WHOEVER RAN THE PULL. Measured 1,706 shifted out of 1,706,
+//       zero exceptions. Same instance, same record, a colleague's laptop ->
+//       different bytes. Machine-dependent output cannot live in a shared repo.
+//     sys_scope / sys_package — present in ~0.95 records per file, so renaming
+//       the app once rewrites the entire mirror. The scope is already obvious
+//       from the folder path (src/Work/, src/Core/), so the value is low and
+//       the blast radius is the whole tree.
+//
+//   KEPT
+//     boolean (21.1%) "0" -> "false", choice/class labels (6.5%) e.g.
+//     sys_class_name -> "Access Control", and every other reference (5.6%)
+//     sys_id -> record name. These are stable, small (~420 KB combined), and
+//     they are the reason a human can read the file at all. A reference
+//     display_value still churns if someone renames its target, but that is
+//     real instance state changing — not the puller's machine.
+//
+// No consumer reads display_value: reconcile ignores metaData.json content
+// entirely and push keys off `value` / the manifest.
+const SYS_DATETIME_RE = /^\d{4}-\d{2}-\d{2}( \d{2}:\d{2}:\d{2})?$/;
+// References carried by nearly every record — one rename churns the whole tree.
+const WHOLE_TREE_REFERENCE_KEYS = ["sys_scope", "sys_package"];
+// Normalize for comparison: the server uses null and "" interchangeably across
+// the two halves of a pair, and String(null) would otherwise read as "null".
+const displayNorm = (v) => v === null || v === undefined ? "" : String(v);
+const shouldDropDisplayValue = (key, value, displayValue) => {
+    if (displayNorm(value) === displayNorm(displayValue))
+        return true;
+    if (SYS_DATETIME_RE.test(displayNorm(value)))
+        return true;
+    if (WHOLE_TREE_REFERENCE_KEYS.indexOf(key) !== -1)
+        return true;
+    return false;
+};
 const stripFieldDisplayValues = (metadata) => {
     for (const key of Object.keys(metadata)) {
         const field = metadata[key];
         if (field !== null &&
             typeof field === "object" &&
+            !Array.isArray(field) &&
             "display_value" in field) {
-            delete field.display_value;
+            const pair = field;
+            if (shouldDropDisplayValue(key, pair.value, pair.display_value)) {
+                delete pair.display_value;
+            }
         }
     }
 };

package/dist/tests/allScopesMetadata.test.js

@@ -113,6 +113,11 @@ function serverMetadata() {
             value: "4e4449a5475c255085d19fd8036d43a0",
             display_value: "Tenon Marketing Work Management",
         },
+        // A plain reference — kept, so the sys_id -> name mapping survives.
+        action: {
+            value: "85de623c33ef2a107b18bc534d5c7b92",
+            display_value: "Parse hashes for to_addresses",
+        },
         _table: "sys_script_include",
         _sys_id: SYS_ID,
         _record_link: "https://tenonworkstudio.service-now.com/sys_script_include.do?sys_id=" + SYS_ID,
@@ -152,14 +157,18 @@ describe("all-scopes writer — metaData.json is normalized, not written raw", f
         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 () {
+    test("applies the selective display_value policy, same as the refresh path", 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");
+        var written = JSON.parse(readRecordFile("metaData.json"));
+        // Dropped: identical, datetime (puller's timezone), sys_scope (whole-tree).
         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" });
+        // Kept: the readable reference name.
+        expect(written.action).toEqual({
+            value: "85de623c33ef2a107b18bc534d5c7b92",
+            display_value: "Parse hashes for to_addresses",
+        });
     });
     test("drops _lastUpdatedOn and writes no wall-clock value", async function () {
         await AllScopes.processManifestForScope(manifestWith([{ name: "metaData", type: "json", content: serverMetadata() }]), tmpRoot, true);

package/dist/tests/stampMetadataContent.test.js

@@ -118,30 +118,96 @@ describe("stampMetadataContent — no generation-time values", () => {
         expect((0, appUtils_1.stampMetadataContent)(arr)).toEqual(arr);
     });
 });
-describe("stampMetadataContent — display_value stripping", () => {
-    it("drops display_value from field pairs, keeping value", () => {
+// display_value handling is SELECTIVE, not a blanket strip. The rule was chosen
+// from a measurement of 43,990 pairs in the real servicenow-files mirror; each
+// test below names the category and why it falls on the side it does.
+describe("stampMetadataContent — display_value DROPPED where it is churn", () => {
+    it("drops it when it is identical to value (zero information, any size)", () => {
+        const out = (0, appUtils_1.stampMetadataContent)(metaFile({
+            name: { value: "UIFilterApiMS", display_value: "UIFilterApiMS" },
+        }));
+        expect(parse(out).name).toEqual({ value: "UIFilterApiMS" });
+    });
+    it("drops identical pairs on large text fields too (script, composition)", () => {
+        // 619 pairs but ~3.7 MB of the corpus — the bulk of the file weight.
+        const big = "var x = 1;\n".repeat(60);
+        const out = (0, appUtils_1.stampMetadataContent)(metaFile({ script: { value: big, display_value: big } }));
+        expect(parse(out).script).toEqual({ value: big });
+    });
+    it("drops it on datetime fields — display_value is the PULLER's timezone", () => {
+        // Measured 1,706 TZ-shifted out of 1,706. `value` is UTC; display_value is
+        // rendered in the local timezone of whoever ran the pull, so keeping it
+        // makes the bytes depend on which laptop synced.
+        const out = (0, appUtils_1.stampMetadataContent)(metaFile({
+            sys_updated_on: { value: "2026-04-29 14:38:51", display_value: "2026-04-29 07:38:51" },
+            sys_created_on: { value: "2026-04-29 14:38:51", display_value: "2026-04-29 07:38:51" },
+        }));
+        const parsed = parse(out);
+        expect(parsed.sys_updated_on).toEqual({ value: "2026-04-29 14:38:51" });
+        expect(parsed.sys_created_on).toEqual({ value: "2026-04-29 14:38:51" });
+    });
+    it("drops it on a date-only value as well", () => {
+        const out = (0, appUtils_1.stampMetadataContent)(metaFile({ start_date: { value: "2026-04-29", display_value: "29-04-2026" } }));
+        expect(parse(out).start_date).toEqual({ value: "2026-04-29" });
+    });
+    it("drops it on sys_scope / sys_package — one app rename churns the whole tree", () => {
+        // Present in ~0.95 records per file. The scope is already obvious from the
+        // folder path (src/Work/, src/Core/), so the value is low and the blast
+        // radius is every file in the mirror.
+        const out = (0, appUtils_1.stampMetadataContent)(metaFile({
+            sys_scope: {
+                value: "4e4449a5475c255085d19fd8036d43a0",
+                display_value: "Tenon Marketing Work Management",
+            },
+            sys_package: {
+                value: "4e4449a5475c255085d19fd8036d43a0",
+                display_value: "Tenon Marketing Work Management",
+            },
+        }));
+        const parsed = parse(out);
+        expect(parsed.sys_scope).toEqual({ value: "4e4449a5475c255085d19fd8036d43a0" });
+        expect(parsed.sys_package).toEqual({ value: "4e4449a5475c255085d19fd8036d43a0" });
+    });
+    it("treats null and \"\" as identical rather than writing \"null\"", () => {
+        const out = (0, appUtils_1.stampMetadataContent)(metaFile({ controlled_by_refs: { value: null, display_value: "" } }));
+        expect(parse(out).controlled_by_refs).toEqual({ value: null });
+    });
+});
+describe("stampMetadataContent — display_value KEPT where it is information", () => {
+    it("keeps a reference's human name (the sys_id -> name mapping)", () => {
+        // This is the readable mapping Documentation/Dovetail-Development.md
+        // documents grepping to walk the record graph. A blanket strip destroyed it.
         const out = (0, appUtils_1.stampMetadataContent)(metaFile({
-            sys_updated_on: { value: "2025-08-21 17:09:02" },
             action: {
                 value: "85de623c33ef2a107b18bc534d5c7b92",
                 display_value: "Parse hashes for to_addresses",
             },
         }));
-        const parsed = parse(out);
-        expect(parsed.action).toEqual({
+        expect(parse(out).action).toEqual({
             value: "85de623c33ef2a107b18bc534d5c7b92",
+            display_value: "Parse hashes for to_addresses",
         });
-        expect(parsed.action.display_value).toBeUndefined();
     });
-    it("strips every field's display_value in one pass", () => {
+    it("keeps boolean renderings (0 -> false)", () => {
+        const out = (0, appUtils_1.stampMetadataContent)(metaFile({
+            active: { value: "1", display_value: "true" },
+            client_callable: { value: "0", display_value: "false" },
+        }));
+        const parsed = parse(out);
+        expect(parsed.active).toEqual({ value: "1", display_value: "true" });
+        expect(parsed.client_callable).toEqual({ value: "0", display_value: "false" });
+    });
+    it("keeps choice / class labels", () => {
         const out = (0, appUtils_1.stampMetadataContent)(metaFile({
-            a: { value: "1", display_value: "One" },
-            b: { value: "2", display_value: "Two" },
+            sys_class_name: { value: "sys_security_acl", display_value: "Access Control" },
+            access: { value: "package_private", display_value: "This application scope only" },
         }));
         const parsed = parse(out);
-        expect(parsed.a).toEqual({ value: "1" });
-        expect(parsed.b).toEqual({ value: "2" });
+        expect(parsed.sys_class_name.display_value).toBe("Access Control");
+        expect(parsed.access.display_value).toBe("This application scope only");
     });
+});
+describe("stampMetadataContent — display_value determinism", () => {
     it("leaves value-only fields and string keys untouched", () => {
         const out = (0, appUtils_1.stampMetadataContent)(metaFile({
             sys_updated_on: { value: "2025-08-21 17:09:02" },
@@ -153,14 +219,30 @@ describe("stampMetadataContent — display_value stripping", () => {
         expect(parsed.name).toEqual({ value: "plain" });
         expect(parsed._record_link).toBe("/incident.do?sys_id=1");
     });
-    it("is idempotent — a display-value-free record stays byte-identical", () => {
-        const clean = {
-            sys_updated_on: { value: "2025-08-21 17:09:02" },
-            action: { value: "abc" },
-            _record_link: "/incident.do?sys_id=1",
+    it("is idempotent across a full mixed record — kept pairs survive a re-stamp", () => {
+        // The failure mode this guards: a rule that keeps a pair on pass 1 but drops
+        // it on pass 2 would churn forever. Run a record carrying every category.
+        const mixed = {
+            sys_updated_on: { value: "2026-04-29 14:38:51", display_value: "2026-04-29 07:38:51" },
+            sys_scope: { value: "4e4449a5", display_value: "Tenon Marketing Work Management" },
+            sys_class_name: { value: "sys_security_acl", display_value: "Access Control" },
+            active: { value: "1", display_value: "true" },
+            action: { value: "85de623c", display_value: "Parse hashes" },
+            name: { value: "same", display_value: "same" },
+            _record_link: "https://tenonworkstudio.service-now.com/incident.do?sys_id=1",
         };
-        const first = (0, appUtils_1.stampMetadataContent)(metaFile(clean));
+        const first = (0, appUtils_1.stampMetadataContent)(metaFile(mixed));
         const second = (0, appUtils_1.stampMetadataContent)(first);
+        const third = (0, appUtils_1.stampMetadataContent)(second);
         expect(second.content).toBe(first.content);
+        expect(third.content).toBe(first.content);
+        // And the kept set is exactly what we intend.
+        const parsed = parse(first);
+        expect(parsed.sys_updated_on.display_value).toBeUndefined();
+        expect(parsed.sys_scope.display_value).toBeUndefined();
+        expect(parsed.name.display_value).toBeUndefined();
+        expect(parsed.sys_class_name.display_value).toBe("Access Control");
+        expect(parsed.active.display_value).toBe("true");
+        expect(parsed.action.display_value).toBe("Parse hashes");
     });
 });

package/dist/tests/syncManifestRefresh.test.js

@@ -334,7 +334,8 @@ describe("syncManifest — --metadata-only rewrites metadata and nothing else",
         // Normalized on the way in — the whole reason to regenerate.
         expect(parsed._record_link).toBe("/sys_script_include.do?sys_id=1");
         expect(parsed._lastUpdatedOn).toBeUndefined();
-        expect(meta).not.toContain("display_value");
+        // datetime display_value is the puller's local timezone — dropped.
+        expect(parsed.sys_updated_on).toEqual({ value: "2026-04-29 14:38:51" });
     });
     test("does not touch field files, even when the instance content differs", async function () {
         writeLocal("Rec", "script", "js", "var local = 1;");

package/package.json

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

package/release-manifest.json

@@ -1,7 +1,33 @@
 {
   "$schema": "dovetail-manifest/v1",
-  "generated_at": "2026-07-28T03:15:38.027Z",
+  "generated_at": "2026-07-28T06:17:01.139Z",
   "events": [
+    {
+      "$schema": "dovetail-release-event/v1",
+      "event_id": "dovetail-core@0.0.116",
+      "package": "@tenonhq/dovetail-core",
+      "version": "0.0.116",
+      "prev_version": "0.0.115",
+      "published_at": "2026-07-28T06:17:01.130Z",
+      "git": {
+        "sha": "ab33183076fdb0eb18a8fc1c8e79b607af3893c4",
+        "tag": "dovetail-core@0.0.116"
+      },
+      "semver_bump": "patch",
+      "commits": [
+        {
+          "sha": "ab3318307",
+          "subject": "fix(core): --metadata-only must not write the scope manifest (#249)",
+          "pr": 249
+        },
+        {
+          "sha": "f77cab2e5",
+          "subject": "chore(release): @tenonhq/dovetail-core@0.0.115 [skip ci]"
+        }
+      ],
+      "exports_delta": null,
+      "narrative": null
+    },
     {
       "$schema": "dovetail-release-event/v1",
       "event_id": "dovetail-core@0.0.115",
@@ -1228,32 +1254,6 @@
       ],
       "exports_delta": null,
       "narrative": null
-    },
-    {
-      "$schema": "dovetail-release-event/v1",
-      "event_id": "dovetail-mcp@0.0.16",
-      "package": "@tenonhq/dovetail-mcp",
-      "version": "0.0.16",
-      "prev_version": "0.0.15",
-      "published_at": "2026-06-15T17:59:30.698Z",
-      "git": {
-        "sha": "51e4e4592d491cd337f5bc1aa93d04f582f555a1",
-        "tag": "dovetail-mcp@0.0.16"
-      },
-      "semver_bump": "patch",
-      "commits": [
-        {
-          "sha": "51e4e4592",
-          "subject": "feat(mcp): per-call instance retarget for servicenow_query_table (#180)",
-          "pr": 180
-        },
-        {
-          "sha": "c5d9106c4",
-          "subject": "chore(release): publish 2 packages [skip ci]"
-        }
-      ],
-      "exports_delta": null,
-      "narrative": null
     }
   ]
 }