@grepr/cli 1.6.5-3542068 → 1.6.7-6789611

package/build/dist/lib/job-patch.js

@@ -39,6 +39,20 @@ const REQUIRED_OP_FIELDS = {
     'add-sink': [['target', 'string'], ['sink', 'object']],
     'remove-sink': [['target', 'string']],
     'set-raw-dataset': [['datasetId', 'string']],
+    'remove-message-attribute': [['attributePath', 'string']],
+    'remove-group-by': [['attributePath', 'string']],
+    // `strategies` is optional (omit to drop all entries for the path), so it stays off the required list.
+    'remove-aggregation-strategy': [['attributePath', 'string']],
+    'remove-reducer-exception': [['predicate', 'object']],
+    'remove-grok-rule': [['pattern', 'string']],
+    'update-source': [['source', 'object']],
+    'update-parser': [['parser', 'object']],
+    // Target-conditional fields (the vendor variant's `filter`) stay with the apply-time guards.
+    'update-sink': [['target', 'string'], ['sink', 'object']],
+    'update-message-attribute': [['from', 'string'], ['to', 'string']],
+    'update-group-by': [['from', 'string'], ['to', 'string']],
+    'update-aggregation-strategy': [['attributePath', 'string'], ['strategies', 'array']],
+    'update-reducer-exception': [['from', 'object'], ['to', 'object']],
 };
 function fieldMatches(value, type) {
     switch (type) {
@@ -202,6 +216,31 @@ function applyOperation(input, op, index) {
             return applyRemoveSink(input, op.target, 'name' in op ? op.name : undefined, index);
         case 'set-raw-dataset':
             return applySetRawDataset(input, op.datasetId);
+        case 'remove-message-attribute':
+            return applyRemoveMessageAttribute(input, op.attributePath, index);
+        case 'remove-group-by':
+            return applyRemoveGroupBy(input, op.attributePath, index);
+        case 'remove-aggregation-strategy':
+            return applyRemoveAggregation(input, op.attributePath, op.strategies, index);
+        case 'remove-reducer-exception':
+            return applyRemoveReducerException(input, op.predicate, index);
+        case 'remove-grok-rule':
+            return applyRemoveGrokRule(input, op.pattern, op.parserName, index);
+        case 'update-source':
+            return applyUpdateSource(input, op.source, index);
+        case 'update-parser':
+            return applyUpdateParser(input, op.parser, index);
+        case 'update-sink':
+            // See add-sink: read the vendor-only `filter` via `in` so a JSON patch's stray field still reaches the guard.
+            return applyUpdateSink(input, op.target, op.sink, 'filter' in op ? op.filter : undefined, index);
+        case 'update-message-attribute':
+            return applyUpdateMessageAttribute(input, op.from, op.to, index);
+        case 'update-group-by':
+            return applyUpdateGroupBy(input, op.from, op.to, index);
+        case 'update-aggregation-strategy':
+            return applyUpdateAggregation(input, op.attributePath, op.strategies, index);
+        case 'update-reducer-exception':
+            return applyUpdateReducerException(input, op.from, op.to, index);
         default:
             return throwUnknownOp(op, index);
     }
@@ -243,6 +282,31 @@ function applyJobGraphOperation(jobGraph, op, index) {
             return jobGraphRemoveSink(jobGraph, op.target, 'name' in op ? op.name : undefined, index);
         case 'set-raw-dataset':
             return jobGraphSetRawDataset(jobGraph, op.datasetId, index);
+        case 'remove-message-attribute':
+            return jobGraphRemoveMessageAttribute(vertices, op.attributePath, index);
+        case 'remove-group-by':
+            return jobGraphRemoveGroupBy(vertices, op.attributePath, index);
+        case 'remove-aggregation-strategy':
+            return jobGraphRemoveAggregation(vertices, op.attributePath, op.strategies, index);
+        case 'remove-reducer-exception':
+            return jobGraphRemoveReducerException(vertices, op.predicate, index);
+        case 'remove-grok-rule':
+            return jobGraphRemoveGrokRule(vertices, op.pattern, op.parserName, index);
+        case 'update-source':
+            return jobGraphUpdateSource(jobGraph, op.source, index);
+        case 'update-parser':
+            return jobGraphUpdateParser(jobGraph, op.parser, index);
+        case 'update-sink':
+            // See add-sink: read the vendor-only `filter` via `in`.
+            return jobGraphUpdateSink(jobGraph, op.target, op.sink, 'filter' in op ? op.filter : undefined, index);
+        case 'update-message-attribute':
+            return jobGraphUpdateMessageAttribute(vertices, op.from, op.to, index);
+        case 'update-group-by':
+            return jobGraphUpdateGroupBy(vertices, op.from, op.to, index);
+        case 'update-aggregation-strategy':
+            return jobGraphUpdateAggregation(vertices, op.attributePath, op.strategies, index);
+        case 'update-reducer-exception':
+            return jobGraphUpdateReducerException(vertices, op.from, op.to, index);
         case 'set-input-field':
         case 'unset-input-field':
             throw new Error(`Operation ${index} (${op.op}): generic template-input paths are not supported on raw job graphs. ` +
@@ -289,20 +353,25 @@ function jobGraphAddReducerException(vertices, predicate, index) {
     reducer.logReducerExceptions = existing;
 }
 function jobGraphAddGrokRule(vertices, pattern, parserName, extractAttribute, index) {
+    const grok = findJobGraphGrokParser(vertices, parserName, 'add-grok-rule', index);
+    applyGrokRuleToParser(grok, pattern, extractAttribute);
+}
+/** Resolve the target grok-parser vertex by name (or the sole grok-parser); shared by add/remove-grok-rule. Throws if absent or ambiguous. */
+function findJobGraphGrokParser(vertices, parserName, opLabel, index) {
     const groks = vertices.filter(v => v.type === GrokParserType.grok_parser);
-    const grok = selectGrokParser(groks, parserName, 'jobGraph.vertices', index);
+    const grok = selectGrokParser(groks, parserName, 'jobGraph.vertices', opLabel, index);
     if (!grok) {
-        throw new Error(`Operation ${index} (add-grok-rule): ${parserName ? `grok-parser "${parserName}" not found` : 'no grok-parser vertex found in jobGraph.vertices'}. ` +
-            `Add a grok-parser vertex via 'grepr job:update' before using add-grok-rule on this pipeline.`);
+        const hint = opLabel === 'add-grok-rule' ? " Add a grok-parser vertex via 'grepr job:update' before using add-grok-rule on this pipeline." : '';
+        throw new Error(`Operation ${index} (${opLabel}): ${parserName ? `grok-parser "${parserName}" not found` : 'no grok-parser vertex found in jobGraph.vertices'}.${hint}`);
     }
-    applyGrokRuleToParser(grok, pattern, extractAttribute);
+    return grok;
 }
-function selectGrokParser(groks, parserName, location, index) {
+function selectGrokParser(groks, parserName, location, opLabel, index) {
     if (parserName) {
         return groks.find(parser => parser.name === parserName);
     }
     if (groks.length > 1) {
-        throw new Error(`Operation ${index} (add-grok-rule): found ${groks.length} grok parsers in ${location}; ` +
+        throw new Error(`Operation ${index} (${opLabel}): found ${groks.length} grok parsers in ${location}; ` +
             `pass parserName to choose the target parser.`);
     }
     return groks[0];
@@ -359,6 +428,119 @@ function applyGrokRuleToParser(parser, pattern, extractAttribute) {
         parser.extractAttribute = extractAttribute;
     }
 }
+/** Consistent "entry not found" error shared by the per-entry remove-* and update-* ops. */
+function entryNotFoundError(index, opLabel, what) {
+    return new Error(`Operation ${index} (${opLabel}): ${what} not found.`);
+}
+// remove-* counterparts of the add-* reducer/remapper/grok writers: mutate the same
+// vertex field, shared verbatim by both backends, throw if the entry is absent.
+function removeMessageAttributeFromRemapper(remapper, attributePath, index) {
+    const parts = splitPath(attributePath, index);
+    const removed = parts.length === 1
+        ? removeString(remapper.messageReservedAttributes, parts[0])
+        : removeStringArray(remapper.messageReservedAttributePaths, parts);
+    if (!removed)
+        throw entryNotFoundError(index, 'remove-message-attribute', `message attribute "${attributePath}"`);
+}
+function removeGroupByFromReducer(reducer, attributePath, index) {
+    const parts = splitPath(attributePath, index);
+    const removed = parts.length === 1
+        ? removeString(reducer.partitionByAttributes, parts[0])
+        : removeStringArray(reducer.partitionByAttributePaths, parts);
+    if (!removed)
+        throw entryNotFoundError(index, 'remove-group-by', `group-by "${attributePath}"`);
+}
+function removeAggregationFromReducer(reducer, attributePath, strategies, index) {
+    if (strategies !== undefined && (!Array.isArray(strategies) || strategies.length === 0)) {
+        throw new Error(`Operation ${index} (remove-aggregation-strategy): strategies must be a non-empty array; ` +
+            `omit it to drop every entry for the path.`);
+    }
+    const parts = splitPath(attributePath, index);
+    const types = strategies?.map(strategyTypeFor);
+    const entries = reducer.attributeMergeStrategyEntries ?? [];
+    const kept = entries.filter(entry => {
+        if (!arraysEqual(entry.attributePath, parts))
+            return true;
+        if (types === undefined)
+            return false; // no strategies given: drop every entry for the path
+        const type = entry.strategy?.type;
+        return type === undefined || !types.includes(type); // else drop only the listed strategies
+    });
+    if (kept.length === entries.length) {
+        const what = strategies === undefined
+            ? `aggregation strategy for "${attributePath}"`
+            : `aggregation strategy [${strategies.join(', ')}] for "${attributePath}"`;
+        throw entryNotFoundError(index, 'remove-aggregation-strategy', what);
+    }
+    reducer.attributeMergeStrategyEntries = kept;
+}
+function removeGrokRuleFromParser(parser, pattern, index) {
+    if (!removeString(parser.grokParsingRules, pattern)) {
+        throw entryNotFoundError(index, 'remove-grok-rule', `grok rule "${pattern}"`);
+    }
+}
+// In-place updates of the dual single/multi-part path lists shared by message
+// attributes (remapper) and group-by (reducer): replace `from` with `to` at its
+// existing position. Both must share arity since the two lists are separate.
+function updateDualListPath(single, multi, from, to, opLabel, noun, index) {
+    const fromParts = splitPath(from, index);
+    const toParts = splitPath(to, index);
+    if ((fromParts.length === 1) !== (toParts.length === 1)) {
+        throw new Error(`Operation ${index} (${opLabel}): cannot change "${from}" to "${to}" in place — ` +
+            `single-part and multi-part paths are stored in different lists; remove + add instead.`);
+    }
+    if (from !== to) {
+        const toExists = toParts.length === 1
+            ? (single ?? []).includes(toParts[0])
+            : (multi ?? []).some(existing => arraysEqual(existing, toParts));
+        if (toExists) {
+            throw new Error(`Operation ${index} (${opLabel}): ${noun} "${to}" already exists; remove "${from}" instead.`);
+        }
+    }
+    const replaced = fromParts.length === 1
+        ? replaceString(single, fromParts[0], toParts[0])
+        : replaceStringArray(multi, fromParts, toParts);
+    if (!replaced)
+        throw entryNotFoundError(index, opLabel, `${noun} "${from}"`);
+}
+function updateMessageAttributeOnRemapper(remapper, from, to, index) {
+    updateDualListPath(remapper.messageReservedAttributes, remapper.messageReservedAttributePaths, from, to, 'update-message-attribute', 'message attribute', index);
+}
+function updateGroupByOnReducer(reducer, from, to, index) {
+    updateDualListPath(reducer.partitionByAttributes, reducer.partitionByAttributePaths, from, to, 'update-group-by', 'group-by', index);
+}
+/** Replace the merge-strategy set for `attributePath` in place, anchored at its first existing entry's position. Errors if the path has no entries. */
+function updateAggregationOnReducer(reducer, attributePath, strategies, index) {
+    if (strategies.length === 0) {
+        throw new Error(`Operation ${index} (update-aggregation-strategy): strategies array must not be empty`);
+    }
+    const parts = splitPath(attributePath, index);
+    const entries = reducer.attributeMergeStrategyEntries ?? [];
+    const at = entries.findIndex(e => arraysEqual(e.attributePath, parts));
+    if (at === -1) {
+        throw entryNotFoundError(index, 'update-aggregation-strategy', `aggregation strategy for "${attributePath}"`);
+    }
+    const replacement = [...new Set(strategies.map(strategyTypeFor))].map(type => ({ attributePath: parts, strategy: { type } }));
+    const kept = entries.filter(e => !arraysEqual(e.attributePath, parts));
+    kept.splice(at, 0, ...replacement); // `at` is the path's first index; all earlier entries are non-path, so it survives the filter.
+    reducer.attributeMergeStrategyEntries = kept;
+}
+/**
+ * Locate `from` among the serialized existing predicates for update-reducer-exception
+ * (entries that aren't predicates serialize to `undefined` and never match). Returns the
+ * index to replace; throws if `from` is absent or `to` would duplicate a different entry.
+ */
+function reducerExceptionUpdateIndex(serialized, from, to, index) {
+    const at = serialized.indexOf(JSON.stringify(from));
+    if (at === -1) {
+        throw entryNotFoundError(index, 'update-reducer-exception', 'matching reducer exception');
+    }
+    const dup = serialized.indexOf(JSON.stringify(to));
+    if (dup !== -1 && dup !== at) {
+        throw new Error(`Operation ${index} (update-reducer-exception): an exception matching "to" already exists; remove the "from" exception instead.`);
+    }
+    return at;
+}
 const DEFAULT_EDGE_OUTPUT = 'output';
 const DEFAULT_EDGE_INPUT = 'input';
 function jobGraphAddSource(jobGraph, source, index) {
@@ -384,7 +566,7 @@ function jobGraphRemoveSource(jobGraph, name, index) {
 }
 function jobGraphAddSink(jobGraph, target, sink, filter, index) {
     assertOperationIdentity(sink, 'add-sink', index, 'sink');
-    assertSinkTargetShape(target, sink, filter, index);
+    assertSinkTargetShape(target, sink, filter, index, 'add-sink');
     // Anchors on a unique log_reducer (assertRawUiLogGraph rejects missing/duplicate).
     assertRawUiLogGraph(jobGraph, 'add-sink', index, [RAW_LOG_REDUCER]);
     if (findVertexIndexByName(jobGraph, sink.name) !== -1) {
@@ -553,6 +735,112 @@ function jobGraphRemoveParser(jobGraph, name, index) {
     const to = outgoing[0];
     addEdgeIfMissing(jobGraph, from.sourceVertex, from.sourcePort, to.targetVertex, to.targetPort);
 }
+// --- Job-graph per-entry removals: anchor on the unique reducer/remapper/grok
+// vertex (the add-path guards), then delegate to the shared remover. ---
+function jobGraphRemoveMessageAttribute(vertices, attributePath, index) {
+    const remapper = findUniqueVertexByType(vertices, LogAttributesRemapperType.log_attributes_remapper, 'remove-message-attribute', index);
+    removeMessageAttributeFromRemapper(remapper, attributePath, index);
+}
+function jobGraphRemoveGroupBy(vertices, attributePath, index) {
+    const reducer = findUniqueVertexByType(vertices, LogReducerType.log_reducer, 'remove-group-by', index);
+    removeGroupByFromReducer(reducer, attributePath, index);
+}
+function jobGraphRemoveAggregation(vertices, attributePath, strategies, index) {
+    const reducer = findUniqueVertexByType(vertices, LogReducerType.log_reducer, 'remove-aggregation-strategy', index);
+    removeAggregationFromReducer(reducer, attributePath, strategies, index);
+}
+/** Remove a raw `EventPredicate` from the reducer's `logReducerExceptions` (mirror of jobGraphAddReducerException). */
+function jobGraphRemoveReducerException(vertices, predicate, index) {
+    const reducer = findUniqueVertexByType(vertices, LogReducerType.log_reducer, 'remove-reducer-exception', index);
+    const serialized = JSON.stringify(predicate);
+    const existing = reducer.logReducerExceptions ?? [];
+    const kept = existing.filter(p => JSON.stringify(p) !== serialized);
+    if (kept.length === existing.length) {
+        throw entryNotFoundError(index, 'remove-reducer-exception', 'matching reducer exception');
+    }
+    reducer.logReducerExceptions = kept;
+}
+function jobGraphRemoveGrokRule(vertices, pattern, parserName, index) {
+    const grok = findJobGraphGrokParser(vertices, parserName, 'remove-grok-rule', index);
+    removeGrokRuleFromParser(grok, pattern, index);
+}
+// --- Job-graph in-place vertex updates: replace the named vertex's config via
+// replaceVertexByName, leaving edges/position untouched. ---
+function jobGraphUpdateSource(jobGraph, source, index) {
+    assertOperationIdentity(source, 'update-source', index, 'source');
+    assertRawUiLogGraph(jobGraph, 'update-source', index, [RAW_PRE_PARSER_FILTER]);
+    if (findVertexIndexByName(jobGraph, source.name) === -1) {
+        throw new Error(`Operation ${index} (update-source): source "${source.name}" not found in jobGraph.vertices.`);
+    }
+    if (!isCanonicalRawSource(jobGraph, source.name)) {
+        throw unsupportedRawShapeError(index, 'update-source', `vertex "${source.name}" is not a canonical UI source feeding ${RAW_PRE_PARSER_FILTER}`);
+    }
+    replaceVertexByName(jobGraph, source.name, source, 'update-source', index);
+}
+function jobGraphUpdateParser(jobGraph, parser, index) {
+    assertOperationIdentity(parser, 'update-parser', index, 'parser');
+    assertRawUiLogGraph(jobGraph, 'update-parser', index, [RAW_PRE_PARSER_FILTER, RAW_PRE_WAREHOUSE_FILTER]);
+    const existing = findVertexByName(jobGraph, parser.name);
+    if (!existing) {
+        throw new Error(`Operation ${index} (update-parser): parser "${parser.name}" not found in jobGraph.vertices.`);
+    }
+    if (!RAW_PARSER_TYPES.has(existing.type)) {
+        throw new Error(`Operation ${index} (update-parser): vertex "${parser.name}" is not a supported parser type.`);
+    }
+    if (!RAW_PARSER_TYPES.has(parser.type)) {
+        throw new Error(`Operation ${index} (update-parser): replacement parser type "${parser.type}" is not supported for raw UI graph parsers.`);
+    }
+    replaceVertexByName(jobGraph, parser.name, parser, 'update-parser', index);
+}
+function jobGraphUpdateSink(jobGraph, target, sink, filter, index) {
+    assertOperationIdentity(sink, 'update-sink', index, 'sink');
+    assertSinkTargetShape(target, sink, filter, index, 'update-sink');
+    if (target === 'processed-logs') {
+        const existing = findIcebergSinkByRole(jobGraph, PROCESSED_LOGS_SINK_NAME_PREFIX, 'processed-logs', 'update-sink', 'update the sink', index);
+        replaceVertexByName(jobGraph, existing.name, { ...sink, name: existing.name }, 'update-sink', index);
+        return;
+    }
+    // vendor: anchor on the unique reducer (as add-sink does), then replace the named vendor sink.
+    assertRawUiLogGraph(jobGraph, 'update-sink', index, [RAW_LOG_REDUCER]);
+    const existing = findVertexByName(jobGraph, sink.name);
+    if (!existing) {
+        throw new Error(`Operation ${index} (update-sink): sink "${sink.name}" not found in jobGraph.vertices.`);
+    }
+    if (!VENDOR_LOG_SINK_TYPES.has(existing.type)) {
+        throw new Error(`Operation ${index} (update-sink): vertex "${sink.name}" is not a vendor sink (type "${existing.type}").`);
+    }
+    replaceVertexByName(jobGraph, sink.name, sink, 'update-sink', index);
+    if (filter !== undefined) {
+        const filterName = `${sink.name}_filter`;
+        if (!findVertexByName(jobGraph, filterName)) {
+            throw new Error(`Operation ${index} (update-sink): sink "${sink.name}" has no generated gating filter "${filterName}" to update; ` +
+                `use remove-sink + add-sink to introduce a gate.`);
+        }
+        replaceRawFilterVertex(jobGraph, filterName, filter, 'update-sink', index);
+    }
+}
+// --- Job-graph in-place updates of reducer-list entries: anchor on the unique
+// reducer/remapper (as the add/remove paths do), then delegate to the shared updater. ---
+function jobGraphUpdateMessageAttribute(vertices, from, to, index) {
+    const remapper = findUniqueVertexByType(vertices, LogAttributesRemapperType.log_attributes_remapper, 'update-message-attribute', index);
+    updateMessageAttributeOnRemapper(remapper, from, to, index);
+}
+function jobGraphUpdateGroupBy(vertices, from, to, index) {
+    const reducer = findUniqueVertexByType(vertices, LogReducerType.log_reducer, 'update-group-by', index);
+    updateGroupByOnReducer(reducer, from, to, index);
+}
+function jobGraphUpdateAggregation(vertices, attributePath, strategies, index) {
+    const reducer = findUniqueVertexByType(vertices, LogReducerType.log_reducer, 'update-aggregation-strategy', index);
+    updateAggregationOnReducer(reducer, attributePath, strategies, index);
+}
+/** Replace the matching raw predicate in the reducer's `logReducerExceptions` in place (mirror of jobGraphAddReducerException). */
+function jobGraphUpdateReducerException(vertices, from, to, index) {
+    const reducer = findUniqueVertexByType(vertices, LogReducerType.log_reducer, 'update-reducer-exception', index);
+    const existing = reducer.logReducerExceptions ?? [];
+    const idx = reducerExceptionUpdateIndex(existing.map(p => JSON.stringify(p)), from, to, index);
+    existing[idx] = to;
+    reducer.logReducerExceptions = existing;
+}
 function rawFilterNameForPhase(phase, index, opLabel) {
     switch (phase) {
         case 'pre-parser':
@@ -750,18 +1038,22 @@ function applyAddReducerException(input, predicate) {
     input.exceptions.push(exception);
 }
 function applyAddGrokRule(input, pattern, parserName, extractAttribute, index) {
-    const parsers = input.parsers;
+    const grok = findTemplateGrokParser(input.parsers, parserName, 'add-grok-rule', index);
+    applyGrokRuleToParser(grok, pattern, extractAttribute);
+}
+/** Resolve the target grok-parser in `input.parsers` by name (or the sole grok-parser); shared by add/remove-grok-rule. Throws if absent, ambiguous, or not a grok-parser. */
+function findTemplateGrokParser(parsers, parserName, opLabel, index) {
     const grok = parserName
         ? parsers.find(p => p.name === parserName)
-        : selectGrokParser(parsers.filter(p => p.type === GrokParserType.grok_parser), undefined, 'input.parsers', index);
+        : selectGrokParser(parsers.filter(p => p.type === GrokParserType.grok_parser), undefined, 'input.parsers', opLabel, index);
     if (!grok) {
-        throw new Error(`Operation ${index} (add-grok-rule): ${parserName ? `parser "${parserName}" not found` : 'no grok-parser found in input.parsers'}. ` +
-            `If you need to introduce one, use add-parser first.`);
+        const hint = opLabel === 'add-grok-rule' ? ' If you need to introduce one, use add-parser first.' : '';
+        throw new Error(`Operation ${index} (${opLabel}): ${parserName ? `parser "${parserName}" not found` : 'no grok-parser found in input.parsers'}.${hint}`);
     }
     if (grok.type !== GrokParserType.grok_parser) {
-        throw new Error(`Operation ${index} (add-grok-rule): parser "${grok.name}" is not a grok-parser`);
+        throw new Error(`Operation ${index} (${opLabel}): parser "${grok.name}" is not a grok-parser`);
     }
-    applyGrokRuleToParser(grok, pattern, extractAttribute);
+    return grok;
 }
 function applySetInputField(input, path, value, index) {
     const parts = splitPath(path, index);
@@ -834,34 +1126,137 @@ function applyRemoveSource(input, name, index) {
     }
     input.sources.splice(idx, 1);
 }
+// --- Template per-entry removals: resolve the same reducer/remapper/grok the add
+// path writes, then delegate to the shared remover. ---
+function applyRemoveMessageAttribute(input, attributePath, index) {
+    const remapper = findRemapper(input);
+    if (!remapper) {
+        throw new Error(`Operation ${index} (remove-message-attribute): no log-attributes-remapper in input.parsers.`);
+    }
+    removeMessageAttributeFromRemapper(remapper, attributePath, index);
+}
+function applyRemoveGroupBy(input, attributePath, index) {
+    removeGroupByFromReducer(input.reducer, attributePath, index);
+}
+function applyRemoveAggregation(input, attributePath, strategies, index) {
+    removeAggregationFromReducer(input.reducer, attributePath, strategies, index);
+}
+/** Remove the `TemplateQueryException` whose predicate matches (mirror of applyAddReducerException). */
+function applyRemoveReducerException(input, predicate, index) {
+    const serialized = JSON.stringify(predicate);
+    const exceptions = input.exceptions ?? [];
+    const kept = exceptions.filter(e => !(e.type === TemplateQueryExceptionType.query_exception &&
+        JSON.stringify(e.predicate) === serialized));
+    if (kept.length === exceptions.length) {
+        throw entryNotFoundError(index, 'remove-reducer-exception', 'matching reducer exception');
+    }
+    input.exceptions = kept;
+}
+function applyRemoveGrokRule(input, pattern, parserName, index) {
+    const grok = findTemplateGrokParser(input.parsers, parserName, 'remove-grok-rule', index);
+    removeGrokRuleFromParser(grok, pattern, index);
+}
+// --- Template in-place vertex updates: replace the matching list entry by name. ---
+function applyUpdateSource(input, source, index) {
+    assertOperationIdentity(source, 'update-source', index, 'source');
+    const idx = input.sources.findIndex(s => s.name === source.name);
+    if (idx === -1) {
+        throw new Error(`Operation ${index} (update-source): source "${source.name}" not found in input.sources.`);
+    }
+    input.sources[idx] = source;
+}
+function applyUpdateParser(input, parser, index) {
+    assertOperationIdentity(parser, 'update-parser', index, 'parser');
+    const idx = input.parsers.findIndex(p => p.name === parser.name);
+    if (idx === -1) {
+        throw new Error(`Operation ${index} (update-parser): parser "${parser.name}" not found in input.parsers.`);
+    }
+    input.parsers[idx] = parser;
+}
+function applyUpdateSink(input, target, sink, filter, index) {
+    assertOperationIdentity(sink, 'update-sink', index, 'sink');
+    assertSinkTargetShape(target, sink, filter, index, 'update-sink');
+    if (target === 'vendor') {
+        const sinks = input.sinks ?? [];
+        const existingEntry = sinks.find(entry => entry.sink?.name === sink.name);
+        if (!existingEntry) {
+            throw new Error(`Operation ${index} (update-sink): sink "${sink.name}" not found in input.sinks.`);
+        }
+        if (filter !== undefined && existingEntry.filter === undefined) {
+            throw new Error(`Operation ${index} (update-sink): sink "${sink.name}" has no gating filter to update; ` +
+                `use remove-sink + add-sink to introduce a gate.`);
+        }
+        const replacementEntry = { sink };
+        if (filter !== undefined) {
+            replacementEntry.filter = filter;
+        }
+        else if (existingEntry.filter !== undefined) {
+            replacementEntry.filter = existingEntry.filter;
+        }
+        input.sinks = sinks.map(entry => (entry === existingEntry ? replacementEntry : entry));
+        return;
+    }
+    // processed-logs: a singular slot, so the replacement is taken as-is — its name is
+    // not matched against the existing sink (unlike the by-name vendor path above).
+    if (input.processedLogsSink === undefined || input.processedLogsSink === null) {
+        throw new Error(`Operation ${index} (update-sink): no processedLogsSink set to update.`);
+    }
+    // Validated as a logs-iceberg-table-sink by assertSinkTargetShape.
+    input.processedLogsSink = sink;
+}
+// --- Template in-place updates of reducer-list entries: resolve the same
+// reducer/remapper the add/remove paths use, then delegate to the shared updater. ---
+function applyUpdateMessageAttribute(input, from, to, index) {
+    const remapper = findRemapper(input);
+    if (!remapper) {
+        throw new Error(`Operation ${index} (update-message-attribute): no log-attributes-remapper in input.parsers.`);
+    }
+    updateMessageAttributeOnRemapper(remapper, from, to, index);
+}
+function applyUpdateGroupBy(input, from, to, index) {
+    updateGroupByOnReducer(input.reducer, from, to, index);
+}
+function applyUpdateAggregation(input, attributePath, strategies, index) {
+    updateAggregationOnReducer(input.reducer, attributePath, strategies, index);
+}
+/** Replace the matching `TemplateQueryException`'s predicate in place (mirror of applyAddReducerException). */
+function applyUpdateReducerException(input, from, to, index) {
+    const exceptions = input.exceptions ?? [];
+    const serialized = exceptions.map(e => e.type === TemplateQueryExceptionType.query_exception
+        ? JSON.stringify(e.predicate)
+        : undefined);
+    const idx = reducerExceptionUpdateIndex(serialized, from, to, index);
+    exceptions[idx] = { type: TemplateQueryExceptionType.query_exception, predicate: to };
+    input.exceptions = exceptions;
+}
 /** Reject a `target` not in {@link SinkTarget}; a typo like `"processed-log"` would otherwise fall through to the processed-logs branch. */
 function assertValidSinkTarget(target, opLabel, index) {
     if (target !== 'vendor' && target !== 'processed-logs') {
         throw new Error(`Operation ${index} (${opLabel}): target must be "vendor" or "processed-logs", got ${JSON.stringify(target)}.`);
     }
 }
-/** Validate the sink type matches the target and `filter` is vendor-only; shared by both backends. */
-function assertSinkTargetShape(target, sink, filter, index) {
-    assertValidSinkTarget(target, 'add-sink', index);
+/** Validate the sink type matches the target and `filter` is vendor-only; shared by add-sink and update-sink on both backends. */
+function assertSinkTargetShape(target, sink, filter, index, opLabel) {
+    assertValidSinkTarget(target, opLabel, index);
     if (target === 'vendor') {
         if (!VENDOR_LOG_SINK_TYPES.has(sink.type)) {
-            throw new Error(`Operation ${index} (add-sink): vendor sink type "${sink.type}" is not supported. ` +
+            throw new Error(`Operation ${index} (${opLabel}): vendor sink type "${sink.type}" is not supported. ` +
                 `Supported: ${[...VENDOR_LOG_SINK_TYPES].join(', ')}.`);
         }
         return;
     }
     // processed-logs
     if (sink.type !== LOGS_ICEBERG_TABLE_SINK_TYPE) {
-        throw new Error(`Operation ${index} (add-sink): target "processed-logs" requires a ${LOGS_ICEBERG_TABLE_SINK_TYPE} sink, got "${sink.type}".`);
+        throw new Error(`Operation ${index} (${opLabel}): target "processed-logs" requires a ${LOGS_ICEBERG_TABLE_SINK_TYPE} sink, got "${sink.type}".`);
     }
     if (filter !== undefined) {
-        throw new Error(`Operation ${index} (add-sink): filter is only supported for target "vendor"; ` +
+        throw new Error(`Operation ${index} (${opLabel}): filter is only supported for target "vendor"; ` +
             `the processed-logs sink has no per-sink filter.`);
     }
 }
 function applyAddSink(input, target, sink, filter, index) {
     assertOperationIdentity(sink, 'add-sink', index, 'sink');
-    assertSinkTargetShape(target, sink, filter, index);
+    assertSinkTargetShape(target, sink, filter, index, 'add-sink');
     if (target === 'vendor') {
         const sinks = input.sinks ?? [];
         if (sinks.some(entry => entry.sink?.name === sink.name)) {
@@ -970,6 +1365,7 @@ function touchesSourceConfig(op) {
     switch (op.op) {
         case 'add-source':
         case 'remove-source':
+        case 'update-source':
             return true;
         case 'set-input-field':
         case 'unset-input-field': {
@@ -984,6 +1380,7 @@ function touchesSinkConfig(op) {
     switch (op.op) {
         case 'add-sink':
         case 'remove-sink':
+        case 'update-sink':
         case 'set-raw-dataset':
             return true;
         case 'set-input-field':
@@ -1049,6 +1446,8 @@ function strategyTypeFor(strategy) {
         case 'max': return MaxAttributesMergeStrategyType.max;
         case 'avg': return AverageAttributesMergeStrategyType.avg;
     }
+    // Reachable only from an untyped JSON patch; the switch is exhaustive for the union.
+    throw new Error(`Unknown aggregation strategy ${JSON.stringify(strategy)}; expected one of: sum, min, max, avg.`);
 }
 function addUniqueString(list, value) {
     if (!list.includes(value))
@@ -1059,6 +1458,46 @@ function addUniqueStringArray(list, value) {
         list.push(value);
     }
 }
+/** Remove the first occurrence of `value`; returns whether anything was removed. */
+function removeString(list, value) {
+    if (!list)
+        return false;
+    const idx = list.indexOf(value);
+    if (idx === -1)
+        return false;
+    list.splice(idx, 1);
+    return true;
+}
+/** Remove the first array equal to `value`; returns whether anything was removed. */
+function removeStringArray(list, value) {
+    if (!list)
+        return false;
+    const idx = list.findIndex(existing => arraysEqual(existing, value));
+    if (idx === -1)
+        return false;
+    list.splice(idx, 1);
+    return true;
+}
+/** Replace the first occurrence of `oldV` with `newV` in place; returns whether `oldV` was found. */
+function replaceString(list, oldV, newV) {
+    if (!list)
+        return false;
+    const idx = list.indexOf(oldV);
+    if (idx === -1)
+        return false;
+    list[idx] = newV;
+    return true;
+}
+/** Replace the first array equal to `oldV` with `newV` in place; returns whether `oldV` was found. */
+function replaceStringArray(list, oldV, newV) {
+    if (!list)
+        return false;
+    const idx = list.findIndex(existing => arraysEqual(existing, oldV));
+    if (idx === -1)
+        return false;
+    list[idx] = newV;
+    return true;
+}
 function arraysEqual(a, b) {
     if (a.length !== b.length)
         return false;