@pattern-stack/codegen 0.16.0 → 0.17.0

package/runtime/base-classes/activity-entity-service.ts

@@ -1,17 +1,19 @@
 /**
  * ActivityEntityService<TRepo, TEntity>
  *
- * Family-specific base service for activity entities.
- * Delegates to an activity repository that provides date-range,
- * user, and opportunity queries.
+ * Family-specific base service for activity / interaction entities. Delegates
+ * to an activity repository that provides date-range, actor (`user_id`), and
+ * config-driven subject queries. The subject FK column is resolved inside the
+ * repository from its `patternConfig` (ADR-031 §4) — the service is
+ * subject-name-agnostic. See ACTIVITY-SUBJECT-1.
  */
 import { BaseService, type IBaseRepository } from './base-service';
 
 export interface IActivityEntityRepository<TEntity> extends IBaseRepository<TEntity> {
   findByDateRange(start: Date, end: Date): Promise<TEntity[]>;
   findByUserId(userId: string): Promise<TEntity[]>;
-  findByOpportunityId(opportunityId: string): Promise<TEntity[]>;
-  findRecentByOpportunityId(opportunityId: string, limit?: number): Promise<TEntity[]>;
+  findBySubjectId(subjectId: string): Promise<TEntity[]>;
+  findRecentBySubjectId(subjectId: string, limit?: number): Promise<TEntity[]>;
 }
 
 export abstract class ActivityEntityService<
@@ -26,23 +28,23 @@ export abstract class ActivityEntityService<
   }
 
   /**
-   * Find all activities for a specific user.
+   * Find all activities for a specific user (actor / owner scoping).
    */
   findByUser(userId: string): Promise<TEntity[]> {
     return this.repository.findByUserId(userId);
   }
 
   /**
-   * Find all activities for a specific opportunity.
+   * Find all activities for a specific subject (config-driven FK column).
    */
-  findByOpportunity(opportunityId: string): Promise<TEntity[]> {
-    return this.repository.findByOpportunityId(opportunityId);
+  findBySubject(subjectId: string): Promise<TEntity[]> {
+    return this.repository.findBySubjectId(subjectId);
   }
 
   /**
-   * Find the most recent activities for an opportunity.
+   * Find the most recent activities for a subject.
    */
-  findRecent(opportunityId: string, limit?: number): Promise<TEntity[]> {
-    return this.repository.findRecentByOpportunityId(opportunityId, limit);
+  findRecent(subjectId: string, limit?: number): Promise<TEntity[]> {
+    return this.repository.findRecentBySubjectId(subjectId, limit);
   }
 }

package/runtime/subsystems/integration/detection-config.schema.ts

@@ -22,10 +22,12 @@
  *     primitive while emitting `Change<T>.source = 'cdc'`. Long-lived
  *     streaming CDC (SFDC Pub-Sub, Debezium) is a separate primitive
  *     deferred to #226-8.
- *   - `webhook` mode requires `eventIdField` so `WebhookChangeSource<T>`
- *     can populate `Change<T>.dedupKey` from the inbound staging row.
+ *   - `webhook` mode's `eventIdField` is optional: `WebhookChangeSource<T>`
+ *     prefers an `eventId` yielded by the queue iterator and falls back to the
+ *     `eventIdField` record extraction (precedence: yielded eventId >
+ *     eventIdField extraction > undefined dedupKey).
  */
-import { z } from 'zod';
+import { z } from "zod";
 
 // ============================================================================
 // Field mapping — provider field → canonical target
@@ -37,9 +39,9 @@ import { z } from 'zod';
  * etc.); the schema does not enumerate transforms — adapters interpret them.
  */
 export const FieldMappingSchema = z.object({
-  source: z.string().min(1),
-  target: z.string().min(1),
-  transform: z.string().min(1).optional(),
+	source: z.string().min(1),
+	target: z.string().min(1),
+	transform: z.string().min(1).optional(),
 });
 
 export type FieldMapping = z.infer<typeof FieldMappingSchema>;
@@ -54,9 +56,9 @@ export type FieldMapping = z.infer<typeof FieldMappingSchema>;
  * adapters interpret per provider.
  */
 export const ResolvedFilterSchema = z.object({
-  field: z.string().min(1),
-  op: z.enum(['eq', 'neq', 'in', 'nin', 'gt', 'gte', 'lt', 'lte']),
-  value: z.unknown(),
+	field: z.string().min(1),
+	op: z.enum(["eq", "neq", "in", "nin", "gt", "gte", "lt", "lte"]),
+	value: z.unknown(),
 });
 
 export type ResolvedFilter = z.infer<typeof ResolvedFilterSchema>;
@@ -66,23 +68,23 @@ export type ResolvedFilter = z.infer<typeof ResolvedFilterSchema>;
 // ============================================================================
 
 const SystemModstampCursorSchema = z.object({
-  kind: z.literal('systemModstamp'),
-  field: z.string().min(1),
+	kind: z.literal("systemModstamp"),
+	field: z.string().min(1),
 });
 
 const ReplayIdCursorSchema = z.object({
-  kind: z.literal('replayId'),
-  field: z.string().min(1),
+	kind: z.literal("replayId"),
+	field: z.string().min(1),
 });
 
 const TimestampCursorSchema = z.object({
-  kind: z.literal('timestamp'),
-  field: z.string().min(1),
+	kind: z.literal("timestamp"),
+	field: z.string().min(1),
 });
 
 const EventIdCursorSchema = z.object({
-  kind: z.literal('eventId'),
-  field: z.string().min(1),
+	kind: z.literal("eventId"),
+	field: z.string().min(1),
 });
 
 /**
@@ -91,8 +93,8 @@ const EventIdCursorSchema = z.object({
  * `field` is metadata for codegen/adapters (the response key the token lives on).
  */
 const HistoryIdCursorSchema = z.object({
-  kind: z.literal('historyId'),
-  field: z.string().min(1),
+	kind: z.literal("historyId"),
+	field: z.string().min(1),
 });
 
 /**
@@ -100,17 +102,17 @@ const HistoryIdCursorSchema = z.object({
  * same divisibility profile as `historyId`.
  */
 const SyncTokenCursorSchema = z.object({
-  kind: z.literal('syncToken'),
-  field: z.string().min(1),
+	kind: z.literal("syncToken"),
+	field: z.string().min(1),
 });
 
-export const CursorStrategySchema = z.discriminatedUnion('kind', [
-  SystemModstampCursorSchema,
-  ReplayIdCursorSchema,
-  TimestampCursorSchema,
-  EventIdCursorSchema,
-  HistoryIdCursorSchema,
-  SyncTokenCursorSchema,
+export const CursorStrategySchema = z.discriminatedUnion("kind", [
+	SystemModstampCursorSchema,
+	ReplayIdCursorSchema,
+	TimestampCursorSchema,
+	EventIdCursorSchema,
+	HistoryIdCursorSchema,
+	SyncTokenCursorSchema,
 ]);
 
 export type CursorStrategy = z.infer<typeof CursorStrategySchema>;
@@ -135,18 +137,20 @@ export type CursorStrategy = z.infer<typeof CursorStrategySchema>;
  * `eventId` is classified atomic conservatively: a generic opaque id is treated
  * all-or-nothing unless a concrete strategy proves it monotonically resumable.
  */
-export const CURSOR_DIVISIBILITY: Readonly<Record<CursorStrategy['kind'], boolean>> = {
-  systemModstamp: true,
-  timestamp: true,
-  replayId: true,
-  eventId: false,
-  historyId: false,
-  syncToken: false,
+export const CURSOR_DIVISIBILITY: Readonly<
+	Record<CursorStrategy["kind"], boolean>
+> = {
+	systemModstamp: true,
+	timestamp: true,
+	replayId: true,
+	eventId: false,
+	historyId: false,
+	syncToken: false,
 };
 
 /** Predicate form of {@link CURSOR_DIVISIBILITY}. */
-export function isDivisibleCursor(kind: CursorStrategy['kind']): boolean {
-  return CURSOR_DIVISIBILITY[kind];
+export function isDivisibleCursor(kind: CursorStrategy["kind"]): boolean {
+	return CURSOR_DIVISIBILITY[kind];
 }
 
 // ============================================================================
@@ -159,19 +163,25 @@ export function isDivisibleCursor(kind: CursorStrategy['kind']): boolean {
  * `field` — used for Stripe-style event endpoints. Defaults to `'poll'`.
  */
 export const PollDetectionSchema = z.object({
-  cursor: CursorStrategySchema,
-  provenance: z.enum(['poll', 'cdc']).optional(),
+	cursor: CursorStrategySchema,
+	provenance: z.enum(["poll", "cdc"]).optional(),
 });
 
 export type PollDetection = z.infer<typeof PollDetectionSchema>;
 
 /**
- * Webhook-mode block. `eventIdField` names the column in the consumer-owned
- * inbound staging row that `WebhookChangeSource<T>` reads to set
- * `Change<T>.dedupKey`.
+ * Webhook-mode block. `eventIdField`, when present, names the field on the
+ * emitted canonical record that `WebhookChangeSource<T>` reads to set
+ * `Change<T>.dedupKey` — used only as the fallback when the queue iterator
+ * does NOT yield an `eventId` alongside the record.
+ *
+ * `eventIdField` is **optional**: a queue iterator that always yields an
+ * `eventId` (vendor delivery metadata, the preferred channel) need not declare
+ * a record field for it. dedupKey precedence is: yielded `eventId` >
+ * `eventIdField` record extraction > undefined.
  */
 export const WebhookDetectionSchema = z.object({
-  eventIdField: z.string().min(1),
+	eventIdField: z.string().min(1).optional(),
 });
 
 export type WebhookDetection = z.infer<typeof WebhookDetectionSchema>;
@@ -181,17 +191,17 @@ export type WebhookDetection = z.infer<typeof WebhookDetectionSchema>;
 // ============================================================================
 
 const PollModeSchema = z.object({
-  mode: z.literal('poll'),
-  poll: PollDetectionSchema,
-  mapping: z.array(FieldMappingSchema).min(1),
-  filters: z.array(ResolvedFilterSchema).default([]),
+	mode: z.literal("poll"),
+	poll: PollDetectionSchema,
+	mapping: z.array(FieldMappingSchema).min(1),
+	filters: z.array(ResolvedFilterSchema).default([]),
 });
 
 const WebhookModeSchema = z.object({
-  mode: z.literal('webhook'),
-  webhook: WebhookDetectionSchema,
-  mapping: z.array(FieldMappingSchema).min(1),
-  filters: z.array(ResolvedFilterSchema).default([]),
+	mode: z.literal("webhook"),
+	webhook: WebhookDetectionSchema,
+	mapping: z.array(FieldMappingSchema).min(1),
+	filters: z.array(ResolvedFilterSchema).default([]),
 });
 
 /**
@@ -201,9 +211,9 @@ const WebhookModeSchema = z.object({
  * (Stripe-style event endpoints) is expressed via `mode: 'poll'` with
  * `poll.provenance: 'cdc'`.
  */
-export const DetectionConfigSchema = z.discriminatedUnion('mode', [
-  PollModeSchema,
-  WebhookModeSchema,
+export const DetectionConfigSchema = z.discriminatedUnion("mode", [
+	PollModeSchema,
+	WebhookModeSchema,
 ]);
 
 export type DetectionConfig = z.infer<typeof DetectionConfigSchema>;

package/runtime/subsystems/integration/webhook-change-source.ts

@@ -7,8 +7,11 @@
  * queue. The primitive owns:
  *
  *   - canonical `Change<T>.source = 'webhook'` stamping;
- *   - `dedupKey` derivation from the configured `webhook.eventIdField` on
- *     the emitted record;
+ *   - `dedupKey` derivation, preferring the `eventId` yielded alongside the
+ *     record by the queue iterator, and falling back to the configured
+ *     `webhook.eventIdField` on the emitted record when no `eventId` is yielded
+ *     (precedence: yielded `eventId` > `eventIdField` record extraction >
+ *     undefined `dedupKey`);
  *   - `externalId` derivation: the mapping entry whose `target === 'external_id'`
  *     names — via its `source` — the field on the emitted record that carries
  *     the canonical external id (mirrors `PollChangeSource`);
@@ -37,16 +40,16 @@
  * into either this primitive or the poll primitive.
  */
 
-import type { DetectionConfig } from './detection-config.schema';
+import type { DetectionConfig } from "./detection-config.schema";
 import type {
-  Change,
-  IChangeSource,
-  IntegrationSubscriptionView,
-} from './integration-change-source.protocol';
+	Change,
+	IChangeSource,
+	IntegrationSubscriptionView,
+} from "./integration-change-source.protocol";
 import type {
-  ChangeIterator,
-  ChangeMiddleware,
-} from './integration-middleware.protocol';
+	ChangeIterator,
+	ChangeMiddleware,
+} from "./integration-middleware.protocol";
 
 // ============================================================================
 // Cursor + queue callback shapes
@@ -66,16 +69,28 @@ export type WebhookCursor = unknown;
  * `userId` / `tenantId`.
  */
 export interface WebhookFetchContext {
-  readonly subscription: IntegrationSubscriptionView;
-  readonly cursor: WebhookCursor | null;
+	readonly subscription: IntegrationSubscriptionView;
+	readonly cursor: WebhookCursor | null;
 }
 
 /**
  * Consumer-supplied queue iterator. Returns an async iterable of
- * `{ record }` pairs — the consumer drains the inbound staging queue and
- * emits already-mapped canonical records `T`. The primitive stamps
- * `source: 'webhook'` and `dedupKey` from the record's configured
- * `webhook.eventIdField`; the consumer is the one who decided when a
+ * `{ record, eventId?, cursor? }` tuples — the consumer drains the inbound
+ * staging queue and emits already-mapped canonical records `T`. The primitive
+ * stamps `source: 'webhook'` and derives `dedupKey` with this precedence:
+ *
+ *   1. the yielded `eventId` (vendor delivery metadata — the queue is the
+ *      right channel for it: a vendor's event id should never need a field
+ *      on the vendor-neutral canonical record);
+ *   2. else the record field named by `webhook.eventIdField`, when configured;
+ *   3. else `undefined`.
+ *
+ * Yielding `eventId` is the safe channel when one canonical record identity
+ * (the `external_id`) can recur across distinct vendor events in a single
+ * drain batch — e.g. a message create and its later edit share an
+ * `external_id` but are different events. Reading dedup identity off the
+ * record (`eventIdField`) collapses those into one `dedupKey`; the yielded
+ * `eventId` keeps them distinct. The consumer is the one who decided when a
  * staging row is "ready" to drain.
  *
  * Webhook mode has no per-record cursor advance — the staging-row drain
@@ -84,33 +99,33 @@ export interface WebhookFetchContext {
  * is whatever the consumer chooses to surface, if anything.
  */
 export type WebhookFetchCallback<T> = (
-  ctx: WebhookFetchContext,
-) => AsyncIterable<{ record: T; cursor?: WebhookCursor }>;
+	ctx: WebhookFetchContext,
+) => AsyncIterable<{ record: T; eventId?: string; cursor?: WebhookCursor }>;
 
 // ============================================================================
 // Constructor options
 // ============================================================================
 
 export interface WebhookChangeSourceOptions<T> {
-  /** Consumer-supplied inbound queue iterator. */
-  readonly queue: WebhookFetchCallback<T>;
-  /**
-   * Parsed detection config. MUST be `mode: 'webhook'`; the constructor
-   * throws if a poll config is supplied. Codegen-emitted factories call
-   * `DetectionConfigSchema.parse(...)` upstream so this is a safety net,
-   * not the primary validation point.
-   */
-  readonly config: DetectionConfig;
-  /**
-   * Optional middleware chain. Same shape and composition rules as
-   * `PollChangeSource` — first element is the outermost layer.
-   */
-  readonly middlewares?: ReadonlyArray<ChangeMiddleware<T>>;
-  /**
-   * Optional human label for run logs (e.g. `'stripe-webhook-charge'`).
-   * Defaults to a derived label based on the mapping at construction.
-   */
-  readonly label?: string;
+	/** Consumer-supplied inbound queue iterator. */
+	readonly queue: WebhookFetchCallback<T>;
+	/**
+	 * Parsed detection config. MUST be `mode: 'webhook'`; the constructor
+	 * throws if a poll config is supplied. Codegen-emitted factories call
+	 * `DetectionConfigSchema.parse(...)` upstream so this is a safety net,
+	 * not the primary validation point.
+	 */
+	readonly config: DetectionConfig;
+	/**
+	 * Optional middleware chain. Same shape and composition rules as
+	 * `PollChangeSource` — first element is the outermost layer.
+	 */
+	readonly middlewares?: ReadonlyArray<ChangeMiddleware<T>>;
+	/**
+	 * Optional human label for run logs (e.g. `'stripe-webhook-charge'`).
+	 * Defaults to a derived label based on the mapping at construction.
+	 */
+	readonly label?: string;
 }
 
 // ============================================================================
@@ -118,100 +133,139 @@ export interface WebhookChangeSourceOptions<T> {
 // ============================================================================
 
 export class WebhookChangeSource<T> implements IChangeSource<T> {
-  public readonly label: string;
-
-  private readonly queue: WebhookFetchCallback<T>;
-  private readonly externalIdSourceField: string;
-  private readonly eventIdSourceField: string;
-  private readonly composed: ChangeIterator<T>;
-
-  constructor(opts: WebhookChangeSourceOptions<T>) {
-    if (opts.config.mode !== 'webhook') {
-      throw new Error(
-        `WebhookChangeSource requires DetectionConfig.mode === 'webhook'; got '${(opts.config as { mode: string }).mode}'`,
-      );
-    }
-    const config = opts.config;
-
-    // Field mapping: locate the entry whose canonical `target` is `external_id`
-    // — mirrors the poll primitive's contract. Adapters emit records
-    // already-mapped; the primitive needs to know which key on T carries the
-    // external id so it can stamp `Change.externalId`. That key is the
-    // mapping's `source` (the field on the emitted record), NOT its `target`
-    // (the canonical column) — they differ whenever the canonical record is
-    // vendor-neutral camelCase (e.g. `source: 'externalId'` → `target: 'external_id'`).
-    const externalIdMapping = config.mapping.find(
-      (m) => m.target === 'external_id',
-    );
-    if (!externalIdMapping) {
-      throw new Error(
-        "WebhookChangeSource: DetectionConfig.mapping must include an entry with target 'external_id' so emitted Change<T>.externalId can be populated",
-      );
-    }
-    this.externalIdSourceField = externalIdMapping.source;
-    this.eventIdSourceField = config.webhook.eventIdField;
-
-    this.queue = opts.queue;
-
-    this.label =
-      opts.label ?? `webhook-change-source:${externalIdMapping.source}`;
-
-    // Compose middleware chain — same shape as PollChangeSource.
-    const inner: ChangeIterator<T> = (sub, cur) => this.fetch(sub, cur);
-    const middlewares = opts.middlewares ?? [];
-    this.composed = middlewares.reduceRight<ChangeIterator<T>>(
-      (next, mw) => mw(next),
-      inner,
-    );
-  }
-
-  listChanges(
-    subscription: IntegrationSubscriptionView,
-    cursor: unknown | null,
-  ): AsyncIterable<Change<T>> {
-    return this.composed(subscription, cursor);
-  }
-
-  private async *fetch(
-    subscription: IntegrationSubscriptionView,
-    cursor: unknown | null,
-  ): AsyncIterable<Change<T>> {
-    const ctx: WebhookFetchContext = {
-      subscription,
-      cursor: cursor as WebhookCursor | null,
-    };
-
-    for await (const { record, cursor: nextCursor } of this.queue(ctx)) {
-      const externalIdRaw = (record as Record<string, unknown>)[
-        this.externalIdSourceField
-      ];
-      if (typeof externalIdRaw !== 'string' || externalIdRaw.length === 0) {
-        throw new Error(
-          `WebhookChangeSource: record missing string '${this.externalIdSourceField}' — emitted records MUST carry the canonical external id keyed by the mapping source`,
-        );
-      }
-      const eventIdRaw = (record as Record<string, unknown>)[
-        this.eventIdSourceField
-      ];
-      if (typeof eventIdRaw !== 'string' || eventIdRaw.length === 0) {
-        throw new Error(
-          `WebhookChangeSource: record missing string '${this.eventIdSourceField}' — webhook records MUST carry the event id (DetectionConfig.webhook.eventIdField) so Change<T>.dedupKey can be populated`,
-        );
-      }
-
-      const change: Change<T> = {
-        externalId: externalIdRaw,
-        // Webhook mode cannot distinguish create vs. update vs. delete on
-        // its own — the orchestrator's diff stage handles classification.
-        // Tombstone / soft-delete detection is consumer-driven (same as
-        // poll mode — see ADR-033).
-        operation: 'updated',
-        record,
-        cursor: nextCursor ?? null,
-        source: 'webhook',
-        dedupKey: eventIdRaw,
-      };
-      yield change;
-    }
-  }
+	public readonly label: string;
+
+	private readonly queue: WebhookFetchCallback<T>;
+	private readonly externalIdSourceField: string;
+	/**
+	 * Record field carrying the event id, when `webhook.eventIdField` is
+	 * configured. Used only as the fallback when the queue iterator does NOT
+	 * yield an `eventId` — see {@link WebhookFetchCallback} for the precedence.
+	 */
+	private readonly eventIdSourceField: string | undefined;
+	private readonly composed: ChangeIterator<T>;
+
+	constructor(opts: WebhookChangeSourceOptions<T>) {
+		if (opts.config.mode !== "webhook") {
+			throw new Error(
+				`WebhookChangeSource requires DetectionConfig.mode === 'webhook'; got '${(opts.config as { mode: string }).mode}'`,
+			);
+		}
+		const config = opts.config;
+
+		// Field mapping: locate the entry whose canonical `target` is `external_id`
+		// — mirrors the poll primitive's contract. Adapters emit records
+		// already-mapped; the primitive needs to know which key on T carries the
+		// external id so it can stamp `Change.externalId`. That key is the
+		// mapping's `source` (the field on the emitted record), NOT its `target`
+		// (the canonical column) — they differ whenever the canonical record is
+		// vendor-neutral camelCase (e.g. `source: 'externalId'` → `target: 'external_id'`).
+		const externalIdMapping = config.mapping.find(
+			(m) => m.target === "external_id",
+		);
+		if (!externalIdMapping) {
+			throw new Error(
+				"WebhookChangeSource: DetectionConfig.mapping must include an entry with target 'external_id' so emitted Change<T>.externalId can be populated",
+			);
+		}
+		this.externalIdSourceField = externalIdMapping.source;
+		this.eventIdSourceField = config.webhook.eventIdField;
+		// `eventIdField` is optional (a callback that always yields `eventId` need
+		// not declare one); `undefined` here just disables the fallback extraction.
+
+		this.queue = opts.queue;
+
+		this.label =
+			opts.label ?? `webhook-change-source:${externalIdMapping.source}`;
+
+		// Compose middleware chain — same shape as PollChangeSource.
+		const inner: ChangeIterator<T> = (sub, cur) => this.fetch(sub, cur);
+		const middlewares = opts.middlewares ?? [];
+		this.composed = middlewares.reduceRight<ChangeIterator<T>>(
+			(next, mw) => mw(next),
+			inner,
+		);
+	}
+
+	listChanges(
+		subscription: IntegrationSubscriptionView,
+		cursor: unknown | null,
+	): AsyncIterable<Change<T>> {
+		return this.composed(subscription, cursor);
+	}
+
+	private async *fetch(
+		subscription: IntegrationSubscriptionView,
+		cursor: unknown | null,
+	): AsyncIterable<Change<T>> {
+		const ctx: WebhookFetchContext = {
+			subscription,
+			cursor: cursor as WebhookCursor | null,
+		};
+
+		for await (const {
+			record,
+			eventId: yieldedEventId,
+			cursor: nextCursor,
+		} of this.queue(ctx)) {
+			const externalIdRaw = (record as Record<string, unknown>)[
+				this.externalIdSourceField
+			];
+			if (typeof externalIdRaw !== "string" || externalIdRaw.length === 0) {
+				throw new Error(
+					`WebhookChangeSource: record missing string '${this.externalIdSourceField}' — emitted records MUST carry the canonical external id keyed by the mapping source`,
+				);
+			}
+
+			// dedupKey precedence: yielded `eventId` > `eventIdField` record
+			// extraction > undefined. The yielded id is vendor delivery metadata
+			// (the right channel for it), and keeps distinct vendor events for the
+			// same `external_id` (e.g. a message and its edit) from collapsing to
+			// one dedupKey — which a record-field extraction would do.
+			const dedupKey = this.deriveDedupKey(yieldedEventId, record);
+
+			const change: Change<T> = {
+				externalId: externalIdRaw,
+				// Webhook mode cannot distinguish create vs. update vs. delete on
+				// its own — the orchestrator's diff stage handles classification.
+				// Tombstone / soft-delete detection is consumer-driven (same as
+				// poll mode — see ADR-033).
+				operation: "updated",
+				record,
+				cursor: nextCursor ?? null,
+				source: "webhook",
+				dedupKey,
+			};
+			yield change;
+		}
+	}
+
+	/**
+	 * Resolve `Change<T>.dedupKey` with the precedence: yielded `eventId` >
+	 * `webhook.eventIdField` record extraction > `undefined`. A non-empty
+	 * yielded `eventId` always wins; otherwise the configured field is read off
+	 * the record (and must be a non-empty string when the field is configured);
+	 * with neither, `dedupKey` is `undefined` (the orchestrator then has no
+	 * delivery-level dedup signal for this change).
+	 */
+	private deriveDedupKey(
+		yieldedEventId: string | undefined,
+		record: T,
+	): string | undefined {
+		if (yieldedEventId !== undefined && yieldedEventId.length > 0) {
+			return yieldedEventId;
+		}
+		if (this.eventIdSourceField === undefined) {
+			return undefined;
+		}
+		const eventIdRaw = (record as Record<string, unknown>)[
+			this.eventIdSourceField
+		];
+		if (typeof eventIdRaw !== "string" || eventIdRaw.length === 0) {
+			throw new Error(
+				`WebhookChangeSource: record missing string '${this.eventIdSourceField}' — a webhook record MUST carry the event id (DetectionConfig.webhook.eventIdField) so Change<T>.dedupKey can be populated, unless the queue iterator yields an 'eventId' alongside the record`,
+			);
+		}
+		return eventIdRaw;
+	}
 }