@firestartr/cli 2.11.0-snapshot-patch-claims → 2.11.0-snapshot-patch-claims-2

package/build/index.js

@@ -166237,7 +166237,7 @@ function isRecord(value) {
 // normalized pointer. Array appends (`add ... /-`) collide on the pointer plus
 // the appended element's `name` when present, so several features can each add
 // a distinct label to /providers/github/labels/- while the same label name from
-// two features still hard-fails.
+// two features is silently deduplicated (or errors if values differ).
 function writeIdentity(patch) {
     const path = normalizePointer(patch.path);
     if (patch.op === 'add' &&
@@ -166248,6 +166248,30 @@ function writeIdentity(patch) {
     }
     return path;
 }
+// Check whether an array at `appendPath`'s parent already contains an element
+// whose `name` matches `value.name`.  Used for the "claim wins" gate: when a
+// feature tries to append an array element that already exists in the claim,
+// the patch is silently dropped.
+function arrayElementExists(doc, appendPath, value) {
+    if (!isRecord(value) || typeof value.name !== 'string')
+        return false;
+    const parentPath = appendPath.slice(0, -2); // strip trailing /-
+    const segments = parentPath
+        .split('/')
+        .slice(1)
+        .map((s) => s.replace(/~1/g, '/').replace(/~0/g, '~'));
+    let cur = doc;
+    for (const seg of segments) {
+        if (cur === null || cur === undefined || typeof cur !== 'object')
+            return false;
+        if (!Object.prototype.hasOwnProperty.call(cur, seg))
+            return false;
+        cur = cur[seg];
+    }
+    if (!Array.isArray(cur))
+        return false;
+    return cur.some((el) => isRecord(el) && el.name === value.name);
+}
 // fast-json-patch does not create intermediate containers for `add`, and
 // appending to an array requires the array to already exist. Ensure every
 // ancestor segment exists before applying an `add`: missing containers are
@@ -166277,9 +166301,7 @@ async function stitchClaim(claimAfterDefaults, preCollectedEnvelopes) {
     if (envelopes.length === 0) {
         return claimAfterDefaults;
     }
-    const violations = [];
-    const seenPaths = new Map();
-    // Collect all patches for deduplication before any gate — normalize once so all gates and apply use same pointer
+    // Normalize all patches once so every gate and the apply phase use the same pointers.
     const normalizedEnvelopes = envelopes.map((env) => ({
         feature: env.feature,
         patches: env.patches.map((p) => ({
@@ -166288,8 +166310,50 @@ async function stitchClaim(claimAfterDefaults, preCollectedEnvelopes) {
             _raw: p.path,
         })),
     }));
-    for (const envelope of normalizedEnvelopes) {
-        for (const patch of envelope.patches) {
+    // ── Phase 1: silently drop patches that should not be applied ──────────
+    //  • Array append whose element already exists in the claim → claim wins
+    //  • Duplicate identity with identical value across features → silent dedup
+    const dropped = new Set(); // "envelopeIdx:patchIdx"
+    const seenIdentities = new Map();
+    for (let ei = 0; ei < normalizedEnvelopes.length; ei++) {
+        const envelope = normalizedEnvelopes[ei];
+        for (let pi = 0; pi < envelope.patches.length; pi++) {
+            const patch = envelope.patches[pi];
+            const key = `${ei}:${pi}`;
+            // Array claim-wins: element already in claim → drop
+            if (patch.op === 'add' && isAppendPointer(patch.path)) {
+                if (arrayElementExists(claimAfterDefaults, patch.path, patch.value)) {
+                    dropped.add(key);
+                    continue;
+                }
+            }
+            // Silent dedup: same identity + same value → drop
+            const identity = writeIdentity(patch);
+            const existing = seenIdentities.get(identity);
+            if (existing) {
+                if (JSON.stringify(existing.value) === JSON.stringify(patch.value)) {
+                    dropped.add(key);
+                    continue;
+                }
+                // Different value — kept here, caught as a violation in Phase 2.
+            }
+            else {
+                seenIdentities.set(identity, {
+                    feature: envelope.feature,
+                    value: patch.value,
+                });
+            }
+        }
+    }
+    // ── Phase 2: collect violations on non-dropped patches ─────────────────
+    const violations = [];
+    const seenForViolations = new Map(); // identity → feature
+    for (let ei = 0; ei < normalizedEnvelopes.length; ei++) {
+        const envelope = normalizedEnvelopes[ei];
+        for (let pi = 0; pi < envelope.patches.length; pi++) {
+            if (dropped.has(`${ei}:${pi}`))
+                continue;
+            const patch = envelope.patches[pi];
             const path = patch.path;
             const raw = patch._raw ?? path;
             // Gate 1: protected path
@@ -166301,54 +166365,32 @@ async function stitchClaim(claimAfterDefaults, preCollectedEnvelopes) {
                     reason: 'protected-path',
                     message: `Feature '${envelope.feature}' patch ${patch.op} ${raw} (normalized ${path}) targets protected claim path`,
                 });
-                // continue to collect other violations for same patch (but avoid duplicate counting)
             }
-            // Gate 3: deduplication — track before overwrite so we report both.
-            // Array appends (`/-`) dedup by element name (see writeIdentity); all
-            // other writes dedup by normalized pointer.
+            // Gate 2: conflicting value from another feature
             const identity = writeIdentity(patch);
-            if (seenPaths.has(identity)) {
+            if (seenForViolations.has(identity)) {
                 violations.push({
                     feature: envelope.feature,
                     op: patch.op,
                     path,
                     reason: 'duplicate-path',
-                    conflictingFeature: seenPaths.get(identity),
-                    message: `Feature '${envelope.feature}' and '${seenPaths.get(identity)}' both write to ${path} (deduplication)`,
+                    conflictingFeature: seenForViolations.get(identity),
+                    message: `Feature '${envelope.feature}' and '${seenForViolations.get(identity)}' both write to ${path} (deduplication)`,
                 });
             }
             else {
-                seenPaths.set(identity, envelope.feature);
-            }
-            // Gate 2: overwrite protection (II-a strict: raw ∪ defaults counts as declared)
-            if (['replace', 'remove', 'add'].includes(patch.op)) {
-                const exists = pointerExists(claimAfterDefaults, path);
-                if (exists) {
-                    // For strict II-a, any op to existing path is overwrite
-                    // We already reported protected if applicable; still report overwrite unless it was protected
-                    // to keep collect-all but avoid double-counting same patch as two reasons? Keep both for visibility.
-                    if (!isProtectedPath(path)) {
-                        violations.push({
-                            feature: envelope.feature,
-                            op: patch.op,
-                            path,
-                            reason: 'overwrite-protected',
-                            message: `Feature '${envelope.feature}' patch ${patch.op} ${raw} (normalized ${path}) would overwrite user/default-declared value`,
-                        });
-                    }
-                }
-                else {
-                    // Path absent — check intermediate parent existence? For now exact path only.
-                    // If patch is `replace` to absent path, fast-json-patch will fail; we let that be an overwrite concern too.
-                    if (['replace', 'remove'].includes(patch.op)) {
-                        violations.push({
-                            feature: envelope.feature,
-                            op: patch.op,
-                            path,
-                            reason: 'overwrite-protected',
-                            message: `Feature '${envelope.feature}' patch ${patch.op} ${raw} (normalized ${path}) targets absent path (replace/remove requires existing value)`,
-                        });
-                    }
+                seenForViolations.set(identity, envelope.feature);
+            }
+            // Gate 3: replace / remove to an absent path
+            if (['replace', 'remove'].includes(patch.op)) {
+                if (!pointerExists(claimAfterDefaults, path)) {
+                    violations.push({
+                        feature: envelope.feature,
+                        op: patch.op,
+                        path,
+                        reason: 'overwrite-protected',
+                        message: `Feature '${envelope.feature}' patch ${patch.op} ${raw} (normalized ${path}) targets absent path (replace/remove requires existing value)`,
+                    });
                 }
             }
         }
@@ -166356,17 +166398,19 @@ async function stitchClaim(claimAfterDefaults, preCollectedEnvelopes) {
     if (violations.length > 0) {
         throw new StitchingError(violations);
     }
-    // No violations — apply patches sequentially (deduplication already ensures no conflicts)
+    // ── Phase 3: apply remaining patches ───────────────────────────────────
     let stitched = JSON.parse(JSON.stringify(claimAfterDefaults));
-    for (const envelope of normalizedEnvelopes) {
-        if (envelope.patches.length === 0)
+    for (let ei = 0; ei < normalizedEnvelopes.length; ei++) {
+        const envelope = normalizedEnvelopes[ei];
+        const patchesToApply = envelope.patches.filter((_, pi) => !dropped.has(`${ei}:${pi}`));
+        if (patchesToApply.length === 0)
             continue;
-        for (const patch of envelope.patches) {
+        for (const patch of patchesToApply) {
             if (patch.op === 'add') {
                 stitched = ensureAddParents(stitched, patch);
             }
         }
-        const result = fast_json_patch.applyPatch(stitched, envelope.patches, false, false);
+        const result = fast_json_patch.applyPatch(stitched, patchesToApply, false, false);
         stitched = result.newDocument;
     }
     return stitched;
@@ -713815,7 +713859,7 @@ const crsStatusSubcommand = {
 };
 
 ;// CONCATENATED MODULE: ./package.json
-const package_namespaceObject = JSON.parse('{"i8":"2.11.0-snapshot-patch-claims"}');
+const package_namespaceObject = JSON.parse('{"i8":"2.11.0-snapshot-patch-claims-2"}');
 ;// CONCATENATED MODULE: ../../package.json
 const package_namespaceObject_1 = {"i8":"2.10.0"};
 // EXTERNAL MODULE: ../../node_modules/semver/index.js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firestartr/cli",
-  "version": "2.11.0-snapshot-patch-claims",
+  "version": "2.11.0-snapshot-patch-claims-2",
   "private": false,
   "description": "Commandline tool",
   "main": "build/main.js",