@grepr/cli 1.14.13-15e1f25 → 1.15.0-c0f7761

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

@@ -1,7 +1,5 @@
-/** Structured patch format for grepr pipelines: a list of ops applied locally before any production write (see {@link JobBackend} for the two substrates). */
-import { ConditionNodeKind, MaskingOperatorType, DropNodeKind, PassthroughNodeKind, SqlNodeKind, SqlNodeOutputRouting, SqlOperationType, SqlOutputStatementType, LogAttributesRemapperType, LogReducerType, GrokParserType, LogsFilterType, DatadogQueryPredicateType, DatadogLogSinkType, SplunkLogSinkType, NewRelicLogSinkType, SumoLogSinkType, OtlpLogSinkType, LogsIcebergTableSinkType, TemplateOperationType, TemplateQueryExceptionType, SumAttributesMergeStrategyType, MinAttributesMergeStrategyType, MaxAttributesMergeStrategyType, AverageAttributesMergeStrategyType, } from '../openapi/openApiTypes.js';
-import { parseEdge } from './job-graph-utils.js';
-import { RAW_ATTRIBUTES_REMAPPER, RAW_ATTRIBUTES_REMAPPER_TYPE, RAW_JSON_PROCESSOR, RAW_JSON_PROCESSOR_TYPE, RAW_LOG_REDUCER, RAW_PARSER_TYPES, RAW_PRE_EXCEPTIONS_FILTER, RAW_PRE_PARSER_FILTER, RAW_PRE_WAREHOUSE_FILTER, } from './job-graph-log-pipeline-constants.js';
+/** Structured patch format for template-backed grepr pipelines: a list of ops applied to `templateInputs.input` locally before any production write. */
+import { ConditionNodeKind, MaskingOperatorType, DropNodeKind, PassthroughNodeKind, SqlNodeKind, SqlNodeOutputRouting, SqlOperationType, SqlOutputStatementType, LogAttributesRemapperType, GrokParserType, DatadogQueryPredicateType, DatadogLogSinkType, SplunkLogSinkType, NewRelicLogSinkType, SumoLogSinkType, OtlpLogSinkType, LogsIcebergTableSinkType, TemplateOperationType, TemplateQueryExceptionType, SumAttributesMergeStrategyType, MinAttributesMergeStrategyType, MaxAttributesMergeStrategyType, AverageAttributesMergeStrategyType, } from '../openapi/openApiTypes.js';
 /** The accepted-phases suffix shared by every template transform-phase error. */
 const ACCEPTED_TRANSFORM_PHASES_MESSAGE = 'Accepted phases are pre-parser, pre-warehouse, and pre-exceptions.';
 /** The downstream pipeline steps a `sql_output` may route to (the generated {@link SqlNodeOutputRouting} values). */
@@ -16,11 +14,6 @@ const VENDOR_LOG_SINK_TYPES = new Set([
     OtlpLogSinkType.otlp_log_sink,
 ]);
 const LOGS_ICEBERG_TABLE_SINK_TYPE = LogsIcebergTableSinkType.logs_iceberg_table_sink;
-// Raw data-lake and processed-logs sinks share the logs-iceberg-table-sink type
-// and are distinguished only by these vertex-name prefixes — a naming convention
-// this CLI must match, not invent.
-const RAW_DATA_LAKE_SINK_NAME_PREFIX = 'raw_data_sink';
-const PROCESSED_LOGS_SINK_NAME_PREFIX = 'processed_logs_';
 /**
  * Required fields per op, keyed by op name. Typed as `Record<JobPatchOp['op'], …>`
  * so a new op added to the union fails to compile until its entry is added here —
@@ -131,23 +124,12 @@ export function parsePatch(raw) {
     }
     return { operations: parsedOperations };
 }
-/** Detect whether a job is template-backed (a `template-operation` vertex) or job-graph. */
-export function detectBackend(job) {
-    const vertices = job.jobGraph?.vertices;
-    if (!Array.isArray(vertices))
-        return 'job-graph';
-    return vertices.some(v => v.type === TemplateOperationType.template_operation) ? 'template' : 'job-graph';
-}
 /**
  * Apply a patch to a fetched job, producing the `SchemaUpdateJob` payload for
- * `job:apply`. Pure (clones input); dispatches on backend. Throws if an op
- * targets a missing field/vertex or a topology op hits a non-UI raw graph.
+ * `job:apply`. Pure (clones input). Throws if the job is not template-backed or
+ * an op targets a missing field.
  */
 export function applyPatch(job, patch) {
-    const backend = detectBackend(job);
-    return backend === 'template' ? applyPatchToTemplate(job, patch) : applyPatchToJobGraph(job, patch);
-}
-function applyPatchToTemplate(job, patch) {
     const cloned = structuredClone(job);
     const templateOp = findTemplateOperation(cloned);
     const input = readTemplateInput(templateOp);
@@ -167,44 +149,14 @@ function applyPatchToTemplate(job, patch) {
         teamIds: cloned.teamIds,
     };
 }
-/**
- * Apply a patch to a job-graph (non-template) pipeline. Clones the job and
- * mutates the resolved graph on the clone (the input is left untouched). Field
- * names match the template inputs except `add-reducer-exception`, which appends
- * a raw `EventPredicate` to the reducer vertex's `logReducerExceptions`. Topology
- * ops require the canonical UI log-pipeline chain.
- */
-function applyPatchToJobGraph(job, patch) {
-    const cloned = structuredClone(job);
-    const jobGraph = cloned.jobGraph;
-    const vertices = jobGraph?.vertices;
-    if (!jobGraph || !Array.isArray(vertices) || vertices.length === 0) {
-        throw new Error('Job has no jobGraph.vertices to patch');
-    }
-    if (!Array.isArray(jobGraph.edges)) {
-        jobGraph.edges = [];
-    }
-    for (let i = 0; i < patch.operations.length; i++) {
-        applyJobGraphOperation(jobGraph, patch.operations[i], i);
-    }
-    if (patch.operations.some(touchesSourceConfig)) {
-        assertProposedJobGraphHasSource(jobGraph);
-    }
-    return {
-        desiredState: cloned.desiredState,
-        fromVersion: cloned.version,
-        jobGraph: cloned.jobGraph,
-        teamIds: cloned.teamIds,
-    };
-}
 function applyOperation(input, op, index) {
     switch (op.op) {
         case 'add-message-attribute':
-            return applyAddMessageAttribute(input, op.attributePath, index);
+            return applyMessageAttributeToRemapper(requireRemapper(input, 'add-message-attribute', index, ADD_PARSER_REMAPPER_HINT), op.attributePath, index);
         case 'add-group-by':
-            return applyAddGroupBy(input, op.attributePath, index);
+            return applyGroupByToReducer(input.reducer, op.attributePath, index);
         case 'add-aggregation-strategy':
-            return applyAddAggregation(input, op.attributePath, op.strategies, index);
+            return applyAggregationToReducer(input.reducer, op.attributePath, op.strategies, index);
         case 'add-reducer-exception':
             return applyAddReducerException(input, op.predicate);
         case 'add-grok-rule':
@@ -244,11 +196,11 @@ function applyOperation(input, op, index) {
         case 'set-raw-dataset':
             return applySetRawDataset(input, op.datasetId);
         case 'remove-message-attribute':
-            return applyRemoveMessageAttribute(input, op.attributePath, index);
+            return removeMessageAttributeFromRemapper(requireRemapper(input, 'remove-message-attribute', index), op.attributePath, index);
         case 'remove-group-by':
-            return applyRemoveGroupBy(input, op.attributePath, index);
+            return removeGroupByFromReducer(input.reducer, op.attributePath, index);
         case 'remove-aggregation-strategy':
-            return applyRemoveAggregation(input, op.attributePath, op.strategies, index);
+            return removeAggregationFromReducer(input.reducer, op.attributePath, op.strategies, index);
         case 'remove-reducer-exception':
             return applyRemoveReducerException(input, op.predicate, index);
         case 'remove-grok-rule':
@@ -261,11 +213,11 @@ function applyOperation(input, op, index) {
             // 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);
+            return updateMessageAttributeOnRemapper(requireRemapper(input, 'update-message-attribute', index), op.from, op.to, index);
         case 'update-group-by':
-            return applyUpdateGroupBy(input, op.from, op.to, index);
+            return updateGroupByOnReducer(input.reducer, op.from, op.to, index);
         case 'update-aggregation-strategy':
-            return applyUpdateAggregation(input, op.attributePath, op.strategies, index);
+            return updateAggregationOnReducer(input.reducer, op.attributePath, op.strategies, index);
         case 'update-reducer-exception':
             return applyUpdateReducerException(input, op.from, op.to, index);
         default:
@@ -277,143 +229,6 @@ function throwUnknownOp(op, index) {
     const unknownOp = op;
     throw new Error(`Operation ${index}: unknown op "${unknownOp.op ?? '(missing)'}"`);
 }
-function applyJobGraphOperation(jobGraph, op, index) {
-    const vertices = jobGraph.vertices;
-    switch (op.op) {
-        case 'add-message-attribute':
-            return jobGraphAddMessageAttribute(vertices, op.attributePath, index);
-        case 'add-group-by':
-            return jobGraphAddGroupBy(vertices, op.attributePath, index);
-        case 'add-aggregation-strategy':
-            return jobGraphAddAggregation(vertices, op.attributePath, op.strategies, index);
-        case 'add-reducer-exception':
-            return jobGraphAddReducerException(vertices, op.predicate, index);
-        case 'add-grok-rule':
-            return jobGraphAddGrokRule(vertices, op.pattern, op.parserName, op.extractAttribute, index);
-        case 'add-parser':
-            return jobGraphAddParser(jobGraph, op.parser, index);
-        case 'remove-parser':
-            return jobGraphRemoveParser(jobGraph, op.name, index);
-        case 'set-filter':
-            return jobGraphSetFilter(jobGraph, op.phase, op.filter, index);
-        case 'clear-filter':
-            return jobGraphClearFilter(jobGraph, op.phase, index);
-        case 'set-sql-transform':
-            throw new Error(`Operation ${index} (set-sql-transform): SQL transform edits are only supported for ` +
-                `template-backed log-reducer jobs in the CLI. This job is a direct job graph. `);
-        case 'set-transform-chain':
-        case 'clear-transform-chain':
-            throw new Error(`Operation ${index} (${op.op}): transform-chain edits are only supported for ` +
-                `template-backed log-reducer jobs in the CLI. This job is a direct job graph. `);
-        case 'set-masking':
-        case 'clear-masking':
-            throw new Error(`Operation ${index} (${op.op}): masking operator edits are only supported for ` +
-                `template-backed log-reducer jobs in the CLI. This job is a direct job graph. `);
-        case 'add-source':
-            return jobGraphAddSource(jobGraph, op.source, index);
-        case 'remove-source':
-            return jobGraphRemoveSource(jobGraph, op.name, index);
-        case 'add-sink':
-            // See the template dispatch: read the target-specific field via `in`.
-            return jobGraphAddSink(jobGraph, op.target, op.sink, 'filter' in op ? op.filter : undefined, index);
-        case 'remove-sink':
-            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. ` +
-                `Use a semantic operation, or apply this change directly via ` +
-                `'grepr job:get' + manual edit + 'grepr job:update'.`);
-        default:
-            return throwUnknownOp(op, index);
-    }
-}
-function findUniqueVertexByType(vertices, type, opLabel, index) {
-    const matches = vertices.filter(v => v.type === type);
-    if (matches.length === 0) {
-        throw new Error(`Operation ${index} (${opLabel}): no ${type} vertex found in jobGraph.vertices. ` +
-            `Non-template pipelines must already include this vertex; this CLI doesn't add new vertices to job-graph pipelines.`);
-    }
-    if (matches.length > 1) {
-        throw new Error(`Operation ${index} (${opLabel}): expected exactly one ${type} vertex but found ${matches.length}. ` +
-            `Ambiguous target; resolve by hand via 'grepr job:get' + 'grepr job:update'.`);
-    }
-    return matches[0];
-}
-function jobGraphAddMessageAttribute(vertices, attributePath, index) {
-    const remapper = findUniqueVertexByType(vertices, LogAttributesRemapperType.log_attributes_remapper, 'add-message-attribute', index);
-    applyMessageAttributeToRemapper(remapper, attributePath, index);
-}
-function jobGraphAddGroupBy(vertices, attributePath, index) {
-    const reducer = findUniqueVertexByType(vertices, LogReducerType.log_reducer, 'add-group-by', index);
-    applyGroupByToReducer(reducer, attributePath, index);
-}
-function jobGraphAddAggregation(vertices, attributePath, strategies, index) {
-    const reducer = findUniqueVertexByType(vertices, LogReducerType.log_reducer, 'add-aggregation-strategy', index);
-    applyAggregationToReducer(reducer, attributePath, strategies, index);
-}
-/** Append a predicate to the reducer's `logReducerExceptions` (stored raw, unlike the template path's `TemplateQueryException` wrapper). */
-function jobGraphAddReducerException(vertices, predicate, index) {
-    const reducer = findUniqueVertexByType(vertices, LogReducerType.log_reducer, 'add-reducer-exception', index);
-    const existing = reducer.logReducerExceptions ?? [];
-    const serialized = JSON.stringify(predicate);
-    if (existing.some(p => JSON.stringify(p) === serialized)) {
-        reducer.logReducerExceptions = existing;
-        return; // idempotent
-    }
-    existing.push(predicate);
-    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', opLabel, index);
-    if (!grok) {
-        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}`);
-    }
-    return grok;
-}
-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} (${opLabel}): found ${groks.length} grok parsers in ${location}; ` +
-            `pass parserName to choose the target parser.`);
-    }
-    return groks[0];
-}
 function applyMessageAttributeToRemapper(remapper, attributePath, index) {
     const parts = splitPath(attributePath, index);
     if (parts.length === 1) {
@@ -471,7 +286,7 @@ 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.
+// field and throw if the entry is absent.
 function removeMessageAttributeFromRemapper(remapper, attributePath, index) {
     const parts = splitPath(attributePath, index);
     const removed = parts.length === 1
@@ -579,339 +394,6 @@ function reducerExceptionUpdateIndex(serialized, from, to, index) {
     }
     return at;
 }
-const DEFAULT_EDGE_OUTPUT = 'output';
-const DEFAULT_EDGE_INPUT = 'input';
-function jobGraphAddSource(jobGraph, source, index) {
-    assertRawUiLogGraph(jobGraph, 'add-source', index, [RAW_PRE_PARSER_FILTER]);
-    assertOperationIdentity(source, 'add-source', index, 'source');
-    if (findVertexIndexByName(jobGraph, source.name) !== -1) {
-        throw new Error(`Operation ${index} (add-source): source "${source.name}" already exists`);
-    }
-    jobGraph.vertices.push(source);
-    addEdgeIfMissing(jobGraph, source.name, DEFAULT_EDGE_OUTPUT, RAW_PRE_PARSER_FILTER, DEFAULT_EDGE_INPUT);
-}
-function jobGraphRemoveSource(jobGraph, name, index) {
-    assertRawUiLogGraph(jobGraph, 'remove-source', index, [RAW_PRE_PARSER_FILTER]);
-    const idx = findVertexIndexByName(jobGraph, name);
-    if (idx === -1) {
-        throw new Error(`Operation ${index} (remove-source): source "${name}" not found in jobGraph.vertices`);
-    }
-    if (!isCanonicalRawSource(jobGraph, name)) {
-        throw unsupportedRawShapeError(index, 'remove-source', `vertex "${name}" is not a canonical UI source feeding ${RAW_PRE_PARSER_FILTER}`);
-    }
-    jobGraph.vertices.splice(idx, 1);
-    removeEdgesTouching(jobGraph, name);
-}
-function jobGraphAddSink(jobGraph, target, sink, filter, index) {
-    assertOperationIdentity(sink, 'add-sink', index, 'sink');
-    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) {
-        throw new Error(`Operation ${index} (add-sink): sink "${sink.name}" already exists`);
-    }
-    // processed-logs is a singular slot — mirror the template-backend guard.
-    // Only reject a reducer-fed iceberg sink (direct or 1-hop through a filter);
-    // a raw data-lake sink fed by pre_data_warehouse_filter is a separate slot.
-    if (target === 'processed-logs' && hasReducerFedIcebergSink(jobGraph)) {
-        throw new Error(`Operation ${index} (add-sink): a logs-iceberg-table-sink already exists. ` +
-            `Remove it first with remove-sink (target: processed-logs) before adding a new one.`);
-    }
-    if (filter !== undefined) {
-        if (typeof filter !== 'object') {
-            throw new Error(`Operation ${index} (add-sink): filter must be an object`);
-        }
-        const filterName = `${sink.name}_filter`;
-        if (findVertexIndexByName(jobGraph, filterName) !== -1) {
-            throw new Error(`Operation ${index} (add-sink): generated filter vertex "${filterName}" already exists`);
-        }
-        const filterVertex = {
-            ...filter,
-            name: filterName,
-            type: LogsFilterType.logs_filter,
-        };
-        jobGraph.vertices.push(filterVertex, sink);
-        addEdgeIfMissing(jobGraph, RAW_LOG_REDUCER, DEFAULT_EDGE_OUTPUT, filterName, DEFAULT_EDGE_INPUT);
-        addEdgeIfMissing(jobGraph, filterName, DEFAULT_EDGE_OUTPUT, sink.name, DEFAULT_EDGE_INPUT);
-        return;
-    }
-    jobGraph.vertices.push(sink);
-    addEdgeIfMissing(jobGraph, RAW_LOG_REDUCER, DEFAULT_EDGE_OUTPUT, sink.name, DEFAULT_EDGE_INPUT);
-}
-function jobGraphRemoveSink(jobGraph, target, name, index) {
-    assertValidSinkTarget(target, 'remove-sink', index);
-    const sinkName = resolveRawSinkToRemove(jobGraph, target, name, index);
-    // If the sink is fed by its generated single-use filter, drop that too.
-    const generatedFilterName = `${sinkName}_filter`;
-    const fedByGeneratedFilter = parsedEdges(jobGraph).some(edge => edge.targetVertex === sinkName && edge.sourceVertex === generatedFilterName);
-    removeVertexByName(jobGraph, sinkName);
-    removeEdgesTouching(jobGraph, sinkName);
-    if (fedByGeneratedFilter && findVertexByName(jobGraph, generatedFilterName)) {
-        removeVertexByName(jobGraph, generatedFilterName);
-        removeEdgesTouching(jobGraph, generatedFilterName);
-    }
-}
-/**
- * Resolve which raw-graph sink a `remove-sink` op targets. `vendor` requires a
- * `name` matching a vendor sink type; `processed-logs` ignores `name` and
- * removes the unique `logs-iceberg-table-sink` (rejecting 0 or multiple).
- */
-function resolveRawSinkToRemove(jobGraph, target, name, index) {
-    if (target === 'vendor') {
-        if (typeof name !== 'string' || name.length === 0) {
-            throw new Error(`Operation ${index} (remove-sink): name is required for target "vendor"`);
-        }
-        const vertex = findVertexByName(jobGraph, name);
-        if (!vertex) {
-            throw new Error(`Operation ${index} (remove-sink): sink "${name}" not found in jobGraph.vertices`);
-        }
-        if (!VENDOR_LOG_SINK_TYPES.has(vertex.type)) {
-            throw new Error(`Operation ${index} (remove-sink): vertex "${name}" is not a vendor sink (type "${vertex.type}")`);
-        }
-        return name;
-    }
-    return findIcebergSinkByRole(jobGraph, PROCESSED_LOGS_SINK_NAME_PREFIX, 'processed-logs', 'remove-sink', 'remove the sink', index).name;
-}
-/**
- * The single `logs-iceberg-table-sink` vertex playing the given role, identified
- * by its name prefix. Selecting by type alone is ambiguous — raw and processed
- * sinks share the type — so a count-based pick can target the wrong dataset sink.
- * Errors on 0 or >1 matches for the role.
- */
-function findIcebergSinkByRole(jobGraph, namePrefix, role, opLabel, action, index) {
-    const matches = jobGraph.vertices.filter(v => v.type === LOGS_ICEBERG_TABLE_SINK_TYPE && v.name.startsWith(namePrefix));
-    if (matches.length !== 1) {
-        throw new Error(`Operation ${index} (${opLabel}): found ${matches.length} ${role} sinks (logs-iceberg-table-sink named "${namePrefix}*"); ` +
-            `expected exactly one to ${action}. Use 'grepr job:get' + 'grepr job:update' to ${action} explicitly.`);
-    }
-    return matches[0];
-}
-function jobGraphSetRawDataset(jobGraph, datasetId, index) {
-    const sink = findIcebergSinkByRole(jobGraph, RAW_DATA_LAKE_SINK_NAME_PREFIX, 'raw data-lake', 'set-raw-dataset', 'set the dataset', index);
-    sink.datasetId = datasetId;
-}
-function jobGraphSetFilter(jobGraph, phase, filter, index) {
-    if (!filter || typeof filter !== 'object') {
-        throw new Error(`Operation ${index} (set-filter): filter must be an object`);
-    }
-    const rawName = rawFilterNameForPhase(phase, index, 'set-filter');
-    assertRawUiLogGraph(jobGraph, 'set-filter', index, [rawName]);
-    replaceRawFilterVertex(jobGraph, rawName, filter, 'set-filter', index);
-}
-function jobGraphClearFilter(jobGraph, phase, index) {
-    const rawName = rawFilterNameForPhase(phase, index, 'clear-filter');
-    assertRawUiLogGraph(jobGraph, 'clear-filter', index, [rawName]);
-    replaceRawFilterVertex(jobGraph, rawName, { predicate: { type: DatadogQueryPredicateType.datadog_query, query: '' } }, 'clear-filter', index);
-}
-function replaceRawFilterVertex(jobGraph, rawName, patch, opLabel, index) {
-    const existing = findVertexByName(jobGraph, rawName);
-    if (!existing) {
-        throw unsupportedRawShapeError(index, opLabel, `vertex "${rawName}" not found`);
-    }
-    replaceVertexByName(jobGraph, rawName, {
-        ...existing,
-        ...patch,
-        type: LogsFilterType.logs_filter,
-        name: rawName,
-    }, opLabel, index);
-}
-function jobGraphAddParser(jobGraph, parser, index) {
-    assertRawUiLogGraph(jobGraph, 'add-parser', index, [RAW_PRE_PARSER_FILTER, RAW_PRE_WAREHOUSE_FILTER]);
-    assertOperationIdentity(parser, 'add-parser', index, 'parser');
-    if (!RAW_PARSER_TYPES.has(parser.type)) {
-        throw new Error(`Operation ${index} (add-parser): parser type "${parser.type}" is not supported for raw UI graph insertion`);
-    }
-    if (findVertexIndexByName(jobGraph, parser.name) !== -1) {
-        throw new Error(`Operation ${index} (add-parser): parser "${parser.name}" already exists`);
-    }
-    if (parser.type === RAW_JSON_PROCESSOR_TYPE) {
-        if (parser.name !== RAW_JSON_PROCESSOR) {
-            throw unsupportedRawShapeError(index, 'add-parser', `json processor must be named "${RAW_JSON_PROCESSOR}"`);
-        }
-        if (findVertexByName(jobGraph, RAW_JSON_PROCESSOR) || findVertexByType(jobGraph, RAW_JSON_PROCESSOR_TYPE)) {
-            throw new Error(`Operation ${index} (add-parser): json-log-processor already exists in the raw graph`);
-        }
-        const successor = orderedParserNames(jobGraph, 'add-parser', index)[0] ?? RAW_PRE_WAREHOUSE_FILTER;
-        return insertRawVertexBetween(jobGraph, parser, RAW_PRE_PARSER_FILTER, successor, 'add-parser', index);
-    }
-    if (parser.type === RAW_ATTRIBUTES_REMAPPER_TYPE) {
-        if (parser.name !== RAW_ATTRIBUTES_REMAPPER) {
-            throw unsupportedRawShapeError(index, 'add-parser', `attributes remapper must be named "${RAW_ATTRIBUTES_REMAPPER}"`);
-        }
-        if (findVertexByName(jobGraph, RAW_ATTRIBUTES_REMAPPER) || findVertexByType(jobGraph, RAW_ATTRIBUTES_REMAPPER_TYPE)) {
-            throw new Error(`Operation ${index} (add-parser): log-attributes-remapper already exists in the raw graph`);
-        }
-        // Locate the json processor by type, not name: live UI graphs use suffixed
-        // names (e.g. json_log_processor_1), and a name-only lookup would silently
-        // fall back to RAW_PRE_PARSER_FILTER and wire the remapper before it.
-        const jsonProcessor = findVertexByType(jobGraph, RAW_JSON_PROCESSOR_TYPE);
-        const predecessor = jsonProcessor ? jsonProcessor.name : RAW_PRE_PARSER_FILTER;
-        const successor = singleMainSuccessor(jobGraph, predecessor, 'add-parser', index);
-        return insertRawVertexBetween(jobGraph, parser, predecessor, successor, 'add-parser', index);
-    }
-    const existingParserNames = orderedParserNames(jobGraph, 'add-parser', index);
-    const predecessor = existingParserNames[existingParserNames.length - 1] ?? RAW_PRE_PARSER_FILTER;
-    insertRawVertexBetween(jobGraph, parser, predecessor, RAW_PRE_WAREHOUSE_FILTER, 'add-parser', index);
-}
-function jobGraphRemoveParser(jobGraph, name, index) {
-    assertRawUiLogGraph(jobGraph, 'remove-parser', index, [RAW_PRE_PARSER_FILTER, RAW_PRE_WAREHOUSE_FILTER]);
-    const parser = findVertexByName(jobGraph, name);
-    if (!parser) {
-        throw new Error(`Operation ${index} (remove-parser): parser "${name}" not found in jobGraph.vertices`);
-    }
-    if (!RAW_PARSER_TYPES.has(parser.type)) {
-        throw new Error(`Operation ${index} (remove-parser): vertex "${name}" is not a supported parser type`);
-    }
-    const incoming = parsedEdges(jobGraph).filter(edge => edge.targetVertex === name);
-    const outgoing = parsedEdges(jobGraph).filter(edge => edge.sourceVertex === name);
-    if (incoming.length !== 1 || outgoing.length !== 1) {
-        throw unsupportedRawShapeError(index, 'remove-parser', `parser "${name}" must have exactly one incoming and one outgoing edge`);
-    }
-    removeVertexByName(jobGraph, name);
-    removeEdgesTouching(jobGraph, name);
-    const from = incoming[0];
-    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':
-            return RAW_PRE_PARSER_FILTER;
-        case 'pre-warehouse':
-            return RAW_PRE_WAREHOUSE_FILTER;
-        case 'pre-exceptions':
-            return RAW_PRE_EXCEPTIONS_FILTER;
-        default:
-            throw new Error(`Operation ${index} (${opLabel}): phase "${phase}" has no canonical UI raw-graph stage. ` +
-                ACCEPTED_TRANSFORM_PHASES_MESSAGE);
-    }
-}
-function assertRawUiLogGraph(jobGraph, opLabel, index, requiredNames) {
-    const seen = new Set();
-    for (const vertex of jobGraph.vertices) {
-        if (typeof vertex.name !== 'string' || vertex.name.length === 0) {
-            throw unsupportedRawShapeError(index, opLabel, 'every vertex must have a non-empty name');
-        }
-        if (seen.has(vertex.name)) {
-            throw unsupportedRawShapeError(index, opLabel, `duplicate vertex name "${vertex.name}"`);
-        }
-        seen.add(vertex.name);
-    }
-    const missing = requiredNames.filter(name => !seen.has(name));
-    if (missing.length > 0) {
-        throw unsupportedRawShapeError(index, opLabel, `missing canonical vertex: ${missing.join(', ')}`);
-    }
-}
-function unsupportedRawShapeError(index, opLabel, detail) {
-    return new Error(`Operation ${index} (${opLabel}): unsupported raw job graph shape. ` +
-        `UI-level topology edits require a canonical UI log pipeline graph; ${detail}.`);
-}
 function assertOperationIdentity(operation, opLabel, index, fieldName) {
     if (!operation || typeof operation !== 'object') {
         throw new Error(`Operation ${index} (${opLabel}): ${fieldName} must be an object`);
@@ -923,145 +405,11 @@ function assertOperationIdentity(operation, opLabel, index, fieldName) {
         throw new Error(`Operation ${index} (${opLabel}): ${fieldName}.type must be a non-empty string`);
     }
 }
-function findVertexByName(jobGraph, name) {
-    return jobGraph.vertices.find(vertex => vertex.name === name);
-}
-function findVertexByType(jobGraph, type) {
-    return jobGraph.vertices.find(vertex => vertex.type === type);
-}
-function findVertexIndexByName(jobGraph, name) {
-    return jobGraph.vertices.findIndex(vertex => vertex.name === name);
-}
-function replaceVertexByName(jobGraph, name, replacement, opLabel, index) {
-    const idx = findVertexIndexByName(jobGraph, name);
-    if (idx === -1) {
-        throw unsupportedRawShapeError(index, opLabel, `vertex "${name}" not found`);
-    }
-    jobGraph.vertices[idx] = replacement;
-}
-function removeVertexByName(jobGraph, name) {
-    const idx = findVertexIndexByName(jobGraph, name);
-    if (idx !== -1) {
-        jobGraph.vertices.splice(idx, 1);
-    }
-}
-function graphEdges(jobGraph) {
-    const graph = jobGraph;
-    if (!Array.isArray(graph.edges)) {
-        graph.edges = []; // Lazily initializes edges to [] if absent — normalizes the schema type omission.
-    }
-    return graph.edges;
-}
-function parsedEdges(jobGraph) {
-    return graphEdges(jobGraph).map((edge, index) => ({ edge, index, ...parseEdge(edge) }));
-}
-/** True if any `logs-iceberg-table-sink` is reachable from `RAW_LOG_REDUCER` within two hops. */
-function hasReducerFedIcebergSink(jobGraph) {
-    const edges = parsedEdges(jobGraph);
-    const reducerNeighbors = new Set(edges.filter(e => e.sourceVertex === RAW_LOG_REDUCER).map(e => e.targetVertex));
-    return jobGraph.vertices.some(v => v.type === LOGS_ICEBERG_TABLE_SINK_TYPE &&
-        (reducerNeighbors.has(v.name) ||
-            edges.some(e => reducerNeighbors.has(e.sourceVertex) && e.targetVertex === v.name)));
-}
-function formatEdge(sourceVertex, sourcePort, targetVertex, targetPort) {
-    const source = sourcePort === DEFAULT_EDGE_OUTPUT ? sourceVertex : `${sourceVertex}:${sourcePort}`;
-    const target = targetPort === DEFAULT_EDGE_INPUT ? targetVertex : `${targetVertex}:${targetPort}`;
-    return `${source} -> ${target}`;
-}
-function addEdgeIfMissing(jobGraph, sourceVertex, sourcePort, targetVertex, targetPort) {
-    const candidate = formatEdge(sourceVertex, sourcePort, targetVertex, targetPort);
-    const exists = parsedEdges(jobGraph).some(edge => edge.sourceVertex === sourceVertex &&
-        edge.sourcePort === sourcePort &&
-        edge.targetVertex === targetVertex &&
-        edge.targetPort === targetPort);
-    if (!exists) {
-        graphEdges(jobGraph).push(candidate);
-    }
-}
-function removeEdgesTouching(jobGraph, name) {
-    const keep = graphEdges(jobGraph).filter(edge => {
-        const parsed = parseEdge(edge);
-        return parsed.sourceVertex !== name && parsed.targetVertex !== name;
-    });
-    jobGraph.edges = keep;
-}
-function removeEdgeAt(jobGraph, index) {
-    graphEdges(jobGraph).splice(index, 1);
-}
-function insertRawVertexBetween(jobGraph, vertex, predecessor, successor, opLabel, index) {
-    const directEdges = parsedEdges(jobGraph).filter(edge => edge.sourceVertex === predecessor && edge.targetVertex === successor);
-    if (directEdges.length !== 1) {
-        throw unsupportedRawShapeError(index, opLabel, `expected exactly one parser-chain edge ${predecessor} -> ${successor}`);
-    }
-    const directEdge = directEdges[0];
-    jobGraph.vertices.push(vertex);
-    removeEdgeAt(jobGraph, directEdge.index);
-    addEdgeIfMissing(jobGraph, predecessor, directEdge.sourcePort, vertex.name, DEFAULT_EDGE_INPUT);
-    addEdgeIfMissing(jobGraph, vertex.name, DEFAULT_EDGE_OUTPUT, successor, directEdge.targetPort);
-}
-function orderedParserNames(jobGraph, opLabel, index) {
-    const names = [];
-    let current = RAW_PRE_PARSER_FILTER;
-    const seen = new Set([current]);
-    while (current !== RAW_PRE_WAREHOUSE_FILTER) {
-        const outgoing = parsedEdges(jobGraph).filter(edge => edge.sourceVertex === current);
-        if (outgoing.length !== 1) {
-            throw unsupportedRawShapeError(index, opLabel, `parser chain vertex "${current}" must have exactly one outgoing main-chain edge`);
-        }
-        const next = outgoing[0].targetVertex;
-        if (next === RAW_PRE_WAREHOUSE_FILTER) {
-            return names;
-        }
-        const nextVertex = findVertexByName(jobGraph, next);
-        if (!nextVertex || !RAW_PARSER_TYPES.has(nextVertex.type)) {
-            throw unsupportedRawShapeError(index, opLabel, `vertex "${next}" between ${RAW_PRE_PARSER_FILTER} and ${RAW_PRE_WAREHOUSE_FILTER} is not a supported parser`);
-        }
-        if (seen.has(next)) {
-            throw unsupportedRawShapeError(index, opLabel, `cycle detected at parser vertex "${next}"`);
-        }
-        names.push(next);
-        seen.add(next);
-        current = next;
-    }
-    return names;
-}
-function singleMainSuccessor(jobGraph, name, opLabel, index) {
-    const outgoing = parsedEdges(jobGraph).filter(edge => edge.sourceVertex === name);
-    if (outgoing.length !== 1) {
-        throw unsupportedRawShapeError(index, opLabel, `vertex "${name}" must have exactly one outgoing main-chain edge`);
-    }
-    return outgoing[0].targetVertex;
-}
-function isCanonicalRawSource(jobGraph, name) {
-    const edges = parsedEdges(jobGraph);
-    const hasIncoming = edges.some(edge => edge.targetVertex === name);
-    const feedsPreParser = edges.some(edge => edge.sourceVertex === name && edge.targetVertex === RAW_PRE_PARSER_FILTER);
-    return !hasIncoming && feedsPreParser;
-}
 function assertProposedTemplateHasSource(input) {
     if (!Array.isArray(input.sources) || input.sources.length === 0) {
         throw new Error('Proposed job graph has zero sources; a log pipeline must keep at least one source.');
     }
 }
-function assertProposedJobGraphHasSource(jobGraph) {
-    if (!jobGraph.vertices.some(vertex => typeof vertex.name === 'string' && isCanonicalRawSource(jobGraph, vertex.name))) {
-        throw new Error('Proposed job graph has zero sources; a log pipeline must keep at least one source.');
-    }
-}
-function applyAddMessageAttribute(input, attributePath, index) {
-    const remapper = findRemapper(input);
-    if (!remapper) {
-        throw new Error(`Operation ${index} (add-message-attribute): no log-attributes-remapper in input.parsers. ` +
-            `Template-backed pipelines normally include a remapper by default; if yours doesn't, add one via add-parser first.`);
-    }
-    applyMessageAttributeToRemapper(remapper, attributePath, index);
-}
-function applyAddGroupBy(input, attributePath, index) {
-    applyGroupByToReducer(input.reducer, attributePath, index);
-}
-function applyAddAggregation(input, attributePath, strategies, index) {
-    applyAggregationToReducer(input.reducer, attributePath, strategies, index);
-}
 function applyAddReducerException(input, predicate) {
     // Wrapped in a TemplateQueryException; matching logs bypass aggregation.
     const serialized = JSON.stringify(predicate);
@@ -1081,9 +429,12 @@ function applyAddGrokRule(input, pattern, parserName, extractAttribute, index) {
 }
 /** 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', opLabel, index);
+    const groks = parsers.filter(p => p.type === GrokParserType.grok_parser);
+    if (!parserName && groks.length > 1) {
+        throw new Error(`Operation ${index} (${opLabel}): found ${groks.length} grok parsers in input.parsers; ` +
+            `pass parserName to choose the target parser.`);
+    }
+    const grok = parserName ? parsers.find(p => p.name === parserName) : groks[0];
     if (!grok) {
         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}`);
@@ -1247,8 +598,8 @@ function findSimpleRootFilterGate(root) {
  * Install or update a filter gate at the phase's transform slot:
  * - empty slot: `IF filter THEN PASSTHROUGH ELSE DROP`
  * - existing simple gate: rebuild with the new predicate, keeping the pass side
- *   and inheriting `inverted`/`lateDataDuration` when the patch omits them (raw
- *   merge semantics — a predicate-only edit must not flip keep↔drop)
+ *   and inheriting `inverted`/`lateDataDuration` when the patch omits them, so a
+ *   predicate-only edit does not flip keep and drop
  * - any other existing chain (e.g. a SqlNode): `IF filter THEN <chain> ELSE DROP`
  */
 function applySetFilter(input, phase, filter, index) {
@@ -1425,21 +776,7 @@ 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);
-}
+// --- Template per-entry removals. ---
 /** Remove the `TemplateQueryException` whose predicate matches (mirror of applyAddReducerException). */
 function applyRemoveReducerException(input, predicate, index) {
     const serialized = JSON.stringify(predicate);
@@ -1503,21 +840,7 @@ function applyUpdateSink(input, target, sink, filter, index) {
     // 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);
-}
+// --- Template in-place updates of reducer-list entries. ---
 /** Replace the matching `TemplateQueryException`'s predicate in place (mirror of applyAddReducerException). */
 function applyUpdateReducerException(input, from, to, index) {
     const exceptions = input.exceptions ?? [];
@@ -1534,7 +857,7 @@ function assertValidSinkTarget(target, opLabel, index) {
         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 add-sink and update-sink on both backends. */
+/** Validate the sink type matches the target and `filter` is vendor-only; shared by add-sink and update-sink. */
 function assertSinkTargetShape(target, sink, filter, index, opLabel) {
     assertValidSinkTarget(target, opLabel, index);
     if (target === 'vendor') {
@@ -1711,9 +1034,9 @@ function touchesSinkConfig(op, index) {
     }
 }
 /**
- * Find the single `template-operation` vertex (exactly one per template-backed
- * job); throws on 0 (non-template) or >1 (unsupported). Accepts `SchemaReadJob`
- * or `SchemaUpdateJob` without casts.
+ * Find the single `template-operation` vertex of a template-backed job. This is
+ * the guard that rejects a raw job graph pipeline (0 matches); it also rejects
+ * more than 1 match. Accepts `SchemaReadJob` or `SchemaUpdateJob` without casts.
  */
 export function findTemplateOperation(job) {
     const vertices = job.jobGraph?.vertices;
@@ -1722,8 +1045,9 @@ export function findTemplateOperation(job) {
     }
     const matches = vertices.filter(v => v.type === TemplateOperationType.template_operation);
     if (matches.length === 0) {
-        throw new Error(`Pipeline is not template-backed (no template-operation vertex). ` +
-            `This helper only applies to template-backed pipelines.`);
+        throw new Error('This pipeline uses a raw job graph (no template-operation vertex). ' +
+            'job:plan, job:draft and job:apply support only template-backed pipelines. ' +
+            'To change a raw job graph, edit it and run job:update.');
     }
     if (matches.length > 1) {
         throw new Error(`Pipeline has ${matches.length} template-operation vertices; expected exactly 1. ` +
@@ -1748,8 +1072,14 @@ function writeTemplateInput(templateOp, input) {
     // templateInputs values are typed `unknown`, so the structured input assigns directly — no cast needed.
     templateOp.templateInputs['input'] = input;
 }
-function findRemapper(input) {
-    return input.parsers.find(p => p.type === LogAttributesRemapperType.log_attributes_remapper);
+const ADD_PARSER_REMAPPER_HINT = `Template-backed pipelines normally include a remapper by default; if yours doesn't, add one via add-parser first.`;
+function requireRemapper(input, opLabel, index, hint) {
+    const remapper = input.parsers.find(p => p.type === LogAttributesRemapperType.log_attributes_remapper);
+    if (!remapper) {
+        const message = `Operation ${index} (${opLabel}): no log-attributes-remapper in input.parsers.`;
+        throw new Error(hint === undefined ? message : `${message} ${hint}`);
+    }
+    return remapper;
 }
 function splitPath(path, index) {
     if (path.length === 0) {