cloudformation-stack-drift-detector 0.1.4 → 0.1.5

package/.jsii

@@ -8440,7 +8440,7 @@
     "stability": "stable"
   },
   "homepage": "https://github.com/gammarers-aws-cdk-constructs/cloudformation-stack-drift-detector.git",
-  "jsiiVersion": "6.0.12 (build 471f453)",
+  "jsiiVersion": "6.0.13 (build 5c05d06)",
   "keywords": [
     "aws",
     "cdk",
@@ -8696,6 +8696,6 @@
       "symbolId": "src/index:TargetResource"
     }
   },
-  "version": "0.1.4",
-  "fingerprint": "Jqn/+VRW42kopD0Ht9dEiVpD114gOnmD3R6NdElONbc="
+  "version": "0.1.5",
+  "fingerprint": "QycxLNj3Gv0Vx1wHojgjVP6oHDL/ks+Ap0DXg8UgKfw="
 }

package/assets/funcs/detector.lambda/index.js

@@ -195,6 +195,7 @@ var DurablePromise = class {
    * Attaches callbacks for the resolution and/or rejection of the Promise
    * Triggers execution if not already started
    */
+  // biome-ignore lint/suspicious/noThenProperty: DurablePromise is deliberately a thenable. The "then" member is part of its public contract, so callers can await a durable operation directly.
   then(onfulfilled, onrejected) {
     return this.ensureExecution().then(onfulfilled, onrejected);
   }
@@ -263,7 +264,8 @@ function durationToSeconds(duration) {
 function terminateForUnrecoverableError(context, error, stepIdentifier) {
   context.terminationManager.terminate({
     reason: error.terminationReason,
-    message: `Unrecoverable error in step ${stepIdentifier}: ${error.message}`
+    message: `Unrecoverable error in step ${stepIdentifier}: ${error.message}`,
+    error
   });
   return new Promise(() => {
   });
@@ -359,7 +361,7 @@ var createRetryStrategy = (config = {}) => {
     }
     const initialDelaySeconds = durationToSeconds(finalConfig.initialDelay);
     const maxDelaySeconds = durationToSeconds(finalConfig.maxDelay);
-    const baseDelay = Math.min(initialDelaySeconds * Math.pow(finalConfig.backoffRate, attemptsMade - 1), maxDelaySeconds);
+    const baseDelay = Math.min(initialDelaySeconds * finalConfig.backoffRate ** (attemptsMade - 1), maxDelaySeconds);
     const finalDelay = finalizeDelaySeconds(baseDelay, finalConfig.jitter);
     return { shouldRetry: true, delay: { seconds: finalDelay } };
   };
@@ -591,8 +593,27 @@ var TerminationReason;
   TerminationReason2["SERDES_FAILED"] = "SERDES_FAILED";
   TerminationReason2["CONTEXT_VALIDATION_ERROR"] = "CONTEXT_VALIDATION_ERROR";
   TerminationReason2["CONFIG_VALIDATION_ERROR"] = "CONFIG_VALIDATION_ERROR";
+  TerminationReason2["NON_DETERMINISM"] = "NON_DETERMINISM";
   TerminationReason2["CUSTOM"] = "CUSTOM";
 })(TerminationReason || (TerminationReason = {}));
+var TERMINATION_CLASS = {
+  [TerminationReason.OPERATION_TERMINATED]: "suspend",
+  [TerminationReason.RETRY_SCHEDULED]: "suspend",
+  [TerminationReason.RETRY_INTERRUPTED_STEP]: "suspend",
+  [TerminationReason.WAIT_SCHEDULED]: "suspend",
+  [TerminationReason.CALLBACK_PENDING]: "suspend",
+  [TerminationReason.CHECKPOINT_FAILED]: "fault",
+  [TerminationReason.SERDES_FAILED]: "fault",
+  [TerminationReason.CONTEXT_VALIDATION_ERROR]: "fault",
+  [TerminationReason.CONFIG_VALIDATION_ERROR]: "fault",
+  [TerminationReason.NON_DETERMINISM]: "fault",
+  // Deliberately unclassified in meaning: CUSTOM says nothing about whether the execution
+  // can continue, so it is treated as a fault. Reporting a fault that was really a suspend
+  // costs one failed execution; the reverse asks the service to retry something that can
+  // never progress, and hides the error while doing so.
+  [TerminationReason.CUSTOM]: "fault"
+};
+var classifyTermination = (reason) => TERMINATION_CLASS[reason] ?? "fault";
 var UnrecoverableError = class extends Error {
   originalError;
   isUnrecoverable = true;
@@ -744,7 +765,7 @@ function createErrorObjectFromError(error, data) {
   };
 }
 var NonDeterministicExecutionError = class extends UnrecoverableExecutionError {
-  terminationReason = TerminationReason.CUSTOM;
+  terminationReason = TerminationReason.NON_DETERMINISM;
   constructor(message) {
     super(message);
     this.name = "NonDeterministicExecutionError";
@@ -839,7 +860,7 @@ var getStepData = (stepData, stepId) => {
   const hashedId = hashId(stepId);
   return stepData[hashedId];
 };
-var createStepHandler = (context, checkpoint, parentContext, createStepId, logger, parentId, getDefaultSerdes, plugin = {}) => {
+var createStepHandler = (context, checkpoint, parentContext, createStepId, logger, parentId, getDefaultSerdes, plugin = {}, pluginOperationName) => {
   return (nameOrFn, fnOrOptions, maybeOptions) => {
     let name;
     let fn;
@@ -860,7 +881,7 @@ var createStepHandler = (context, checkpoint, parentContext, createStepId, logge
       validateReplayConsistency(stepId, { type: OperationType.STEP, name, subType: OperationSubType.STEP }, stepData, context);
       const opInfo = {
         id: hashId(stepId),
-        name,
+        name: pluginOperationName ?? name,
         type: OperationType.STEP,
         subType: OperationSubType.STEP,
         parentId: parentId ? hashId(parentId) : void 0
@@ -1719,15 +1740,7 @@ var createWaitForConditionHandler = (context, checkpoint, createStepId, logger,
         if (stepData?.Status === OperationStatus.STARTED || stepData?.Status === OperationStatus.READY) {
           const checkpointData = stepData.StepDetails?.Result;
           if (checkpointData) {
-            try {
-              const serdesContext = {
-                entityId: stepId,
-                durableExecutionArn: context.durableExecutionArn
-              };
-              currentState = await serdes.deserialize(checkpointData, serdesContext);
-            } catch {
-              currentState = config.initialState;
-            }
+            currentState = await safeDeserialize(serdes, checkpointData, stepId, name, context.terminationManager, context.durableExecutionArn);
           } else {
             currentState = config.initialState;
           }
@@ -1820,7 +1833,7 @@ var createWaitForConditionHandler = (context, checkpoint, createStepId, logger,
             }
           });
           stepData = context.getStepData(stepId);
-          const attemptEndInfo = toAttemptEndInfo(stepData, AttemptEndInfoOutcome.FAILED, {
+          const attemptEndInfo = toAttemptEndInfo(stepData, AttemptEndInfoOutcome.SUCCEEDED, {
             attempt: currentAttempt
           });
           backfillOperationInfo(attemptEndInfo, opInfo);
@@ -1926,7 +1939,7 @@ var createPassThroughSerdes = () => ({
   serialize: async (value) => value,
   deserialize: async (data) => data
 });
-var createCallback = (context, checkpoint, createStepId, checkAndUpdateReplayMode, parentId, getDefaultCallbackDeserializer, plugin = {}) => {
+var createCallback = (context, checkpoint, createStepId, checkAndUpdateReplayMode, parentId, getDefaultCallbackDeserializer, plugin = {}, pluginOperationName) => {
   return (nameOrConfig, maybeConfig) => {
     let name;
     let config;
@@ -1940,7 +1953,7 @@ var createCallback = (context, checkpoint, createStepId, checkAndUpdateReplayMod
     const serdes = config?.serdes || (getDefaultCallbackDeserializer ? getDefaultCallbackDeserializer() : createPassThroughSerdes());
     const opInfo = {
       id: hashId(stepId),
-      name,
+      name: pluginOperationName ?? name,
       type: OperationType.CALLBACK,
       subType: OperationSubType.CALLBACK,
       parentId: parentId ? hashId(parentId) : void 0
@@ -2108,12 +2121,14 @@ var createWaitForCallbackHandler = (context, peekStepId, runInChildContext, getD
             serdes: createPassThroughSerdes()
           }
         } : void 0;
-        const [callbackPromise, callbackId] = await childCtx.createCallback(createCallbackConfig);
+        const internalCtx = childCtx;
+        const [callbackPromise, callbackId] = await internalCtx._createCallbackWithPluginOperationName(name ? `${name}-callback` : void 0, createCallbackConfig);
         log("\u{1F194}", "Callback created:", {
           callbackId,
           name
         });
-        await childCtx.step(async (stepContext) => {
+        const submitterOptions = config?.retryStrategy ? { retryStrategy: config.retryStrategy } : void 0;
+        await internalCtx._stepWithPluginOperationName(name ? `${name}-submitter` : void 0, async (stepContext) => {
           const callbackContext = {
             logger: stepContext.logger
           };
@@ -2126,7 +2141,7 @@ var createWaitForCallbackHandler = (context, peekStepId, runInChildContext, getD
             callbackId,
             name
           });
-        }, config?.retryStrategy ? { retryStrategy: config.retryStrategy } : void 0);
+        }, submitterOptions);
         log("\u23F3", "Waiting for callback completion:", {
           callbackId,
           name
@@ -2165,6 +2180,36 @@ var createWaitForCallbackHandler = (context, peekStepId, runInChildContext, getD
     });
   };
 };
+var ITEM_STATUS_SUCCEEDED = "S";
+var ITEM_STATUS_FAILED = "F";
+var ITEM_STATUS_INCOMPLETE = "-";
+var encodeItemStatuses = (result) => {
+  const items = result.all ?? [];
+  if (items.length === 0) {
+    return "";
+  }
+  let maxIndex = -1;
+  for (const item of items) {
+    if (typeof item.index === "number" && item.index > maxIndex) {
+      maxIndex = item.index;
+    }
+  }
+  if (maxIndex < 0) {
+    return "";
+  }
+  const encoded = new Array(maxIndex + 1).fill(ITEM_STATUS_INCOMPLETE);
+  for (const item of items) {
+    if (typeof item.index !== "number") {
+      continue;
+    }
+    if (item.status === BatchItemStatus.SUCCEEDED) {
+      encoded[item.index] = ITEM_STATUS_SUCCEEDED;
+    } else if (item.status === BatchItemStatus.FAILED) {
+      encoded[item.index] = ITEM_STATUS_FAILED;
+    }
+  }
+  return encoded.join("");
+};
 var createParallelSummaryGenerator = () => (result) => {
   return JSON.stringify({
     type: "ParallelResult",
@@ -2173,7 +2218,8 @@ var createParallelSummaryGenerator = () => (result) => {
     failureCount: result.failureCount,
     startedCount: result.startedCount,
     completionReason: result.completionReason,
-    status: result.status
+    status: result.status,
+    itemStatuses: encodeItemStatuses(result)
   });
 };
 var createMapSummaryGenerator = () => (result) => {
@@ -2183,7 +2229,8 @@ var createMapSummaryGenerator = () => (result) => {
     successCount: result.successCount,
     failureCount: result.failureCount,
     completionReason: result.completionReason,
-    status: result.status
+    status: result.status,
+    itemStatuses: encodeItemStatuses(result)
   });
 };
 var composeSummaryGenerator = (internalGenerator, customGenerator) => (result) => {
@@ -2671,18 +2718,21 @@ var ConcurrencyController = class {
         itemCount: items.length
       });
       let recordedCompletionReason;
+      let recordedItemStatuses;
       if (entityId && executionContext) {
         const stepData = executionContext.getStepData(entityId);
         const summaryPayload = stepData?.ContextDetails?.Result;
         if (summaryPayload) {
           recordedCompletionReason = this.parseRecordedCompletionReason(summaryPayload);
+          recordedItemStatuses = this.parseRecordedItemStatuses(summaryPayload);
           log("\u{1F4CA}", "Recovered completion reason from summary:", {
-            recordedCompletionReason
+            recordedCompletionReason,
+            hasRecordedItemStatuses: recordedItemStatuses !== void 0
           });
         }
       }
       if (entityId && executionContext) {
-        return await this.replayItems(items, executor, parentContext, config, recordedCompletionReason, executionContext, entityId);
+        return await this.replayItems(items, executor, parentContext, config, recordedCompletionReason, recordedItemStatuses, executionContext, entityId);
       } else {
         log("\u26A0\uFE0F", "No entity id or execution context found, falling back to concurrent execution");
       }
@@ -2708,7 +2758,7 @@ var ConcurrencyController = class {
       const parsed = JSON.parse(summaryPayload);
       if (parsed && typeof parsed === "object") {
         const reason = parsed.completionReason;
-        if (typeof reason === "string" && Object.prototype.hasOwnProperty.call(VALID_COMPLETION_REASONS, reason)) {
+        if (typeof reason === "string" && Object.hasOwn(VALID_COMPLETION_REASONS, reason)) {
           return reason;
         }
       }
@@ -2717,7 +2767,128 @@ var ConcurrencyController = class {
     }
     return void 0;
   }
-  async replayItems(items, executor, parentContext, config, recordedCompletionReason, executionContext, parentEntityId) {
+  /**
+   * Extracts the recorded per-item completion markers from a checkpointed batch
+   * payload. One character per item in index order (`S`/`F`/`-`).
+   *
+   * Two payload shapes are recognised, because ReplayChildren is reached two
+   * ways:
+   *
+   *  - The summary written when the result exceeded the checkpoint size limit,
+   *    which carries `itemStatuses` directly.
+   *  - The FULL serialized BatchResult written when `childOperationsDepth` opts
+   *    a context into child preservation. That path sets ReplayChildren while
+   *    checkpointing the whole result, so the summary generator never runs and
+   *    there is no `itemStatuses` — but the payload already contains
+   *    `all: [{ index, status }]`, which carries the same information.
+   *
+   * Validated as strictly as `parseRecordedCompletionReason`: legacy checkpoints
+   * can carry arbitrary JSON (including free-form strings from pre-fix custom
+   * generators), and the consequence here is terminality decisions rather than a
+   * display field. `Object.hasOwn` keeps inherited keys like `constructor` out,
+   * and the marker alphabet is checked so a crafted value cannot be read as
+   * terminality.
+   *
+   * Returns undefined when the payload is absent, unparseable, or carries
+   * neither shape — in which case replay falls back to probing.
+   */
+  parseRecordedItemStatuses(summaryPayload) {
+    if (typeof summaryPayload !== "string") {
+      return void 0;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(summaryPayload);
+    } catch {
+      return void 0;
+    }
+    if (!parsed || typeof parsed !== "object") {
+      return void 0;
+    }
+    const record = parsed;
+    if (Object.hasOwn(record, "itemStatuses")) {
+      const statuses = record.itemStatuses;
+      if (typeof statuses === "string" && statuses.length > 0 && /^[SF-]+$/.test(statuses)) {
+        return statuses;
+      }
+      return void 0;
+    }
+    if (Object.hasOwn(record, "all") && Array.isArray(record.all)) {
+      return this.encodeStatusesFromBatchItems(record.all);
+    }
+    return void 0;
+  }
+  /**
+   * Derives the per-item markers from a checkpointed `all` array, so the
+   * `childOperationsDepth` path (which checkpoints the full result and therefore
+   * has no summary envelope) gets the same treatment as a summarized batch.
+   */
+  encodeStatusesFromBatchItems(items) {
+    let maxIndex = -1;
+    for (const entry of items) {
+      if (!entry || typeof entry !== "object") {
+        continue;
+      }
+      const index = entry.index;
+      if (typeof index === "number" && index > maxIndex) {
+        maxIndex = index;
+      }
+    }
+    if (maxIndex < 0) {
+      return void 0;
+    }
+    const encoded = new Array(maxIndex + 1).fill("-");
+    for (const entry of items) {
+      if (!entry || typeof entry !== "object") {
+        continue;
+      }
+      const item = entry;
+      if (typeof item.index !== "number") {
+        continue;
+      }
+      if (item.status === BatchItemStatus.SUCCEEDED) {
+        encoded[item.index] = "S";
+      } else if (item.status === BatchItemStatus.FAILED) {
+        encoded[item.index] = "F";
+      }
+    }
+    return encoded.join("");
+  }
+  /**
+   * Whether a virtual item finished, inferred from its own checkpointed
+   * operations. Used ONLY for summaries written before per-item statuses were
+   * recorded.
+   *
+   * A virtual (FLAT) item has no context checkpoint, so its operations are
+   * probed directly. Probing only the first operation would be unsound: an item
+   * that was still in flight can have a SUCCEEDED first operation and would be
+   * misread as finished. Every recorded operation is therefore walked, and the
+   * item counts as finished only if all of them are terminal.
+   *
+   * Step ids come from a per-context counter starting at 1 and increasing by one
+   * per operation, so the recorded ids are contiguous and the walk stops at the
+   * first gap.
+   *
+   * Residual limitation, unavoidable without recorded statuses: an item whose
+   * body creates no durable operation leaves nothing to probe and is
+   * indistinguishable from one that never started, so it reads as unfinished and
+   * is not rebuilt.
+   */
+  isVirtualItemTerminalByProbe(executionContext, childEntityId) {
+    let found = false;
+    for (let opIndex = 1; ; opIndex++) {
+      const op = executionContext.getStepData(`${childEntityId}-${opIndex}`);
+      if (!op) {
+        break;
+      }
+      found = true;
+      if (op.Status !== OperationStatus.SUCCEEDED && op.Status !== OperationStatus.FAILED) {
+        return false;
+      }
+    }
+    return found;
+  }
+  async replayItems(items, executor, parentContext, config, recordedCompletionReason, recordedItemStatuses, executionContext, parentEntityId) {
     const resultItems = [];
     log("\u{1F504}", `Replaying ${items.length} items from child checkpoints`, {
       recordedCompletionReason
@@ -2726,7 +2897,16 @@ var ConcurrencyController = class {
     for (const item of items) {
       const childEntityId = `${parentEntityId}-${stepCounter + 1}`;
       const childStepData = executionContext.getStepData(childEntityId);
-      const isTerminal = !!childStepData && (childStepData.Status === OperationStatus.SUCCEEDED || childStepData.Status === OperationStatus.FAILED);
+      const childRecordIsTerminal = !childStepData || childStepData.Status === OperationStatus.SUCCEEDED || childStepData.Status === OperationStatus.FAILED;
+      let isTerminal;
+      if (recordedItemStatuses !== void 0) {
+        const marker = recordedItemStatuses[item.index];
+        isTerminal = (marker === "S" || marker === "F") && childRecordIsTerminal;
+      } else if (childStepData) {
+        isTerminal = childStepData.Status === OperationStatus.SUCCEEDED || childStepData.Status === OperationStatus.FAILED;
+      } else {
+        isTerminal = this.isVirtualItemTerminalByProbe(executionContext, childEntityId);
+      }
       if (isTerminal) {
         try {
           const result = await parentContext.runInChildContext(item.name || item.id, (childContext) => executor(item, childContext), {
@@ -3222,9 +3402,20 @@ var DurableContextImpl = class {
     return this.modeManagement.withDurableModeManagement(operation);
   }
   step(nameOrFn, fnOrOptions, maybeOptions) {
+    return this.stepInternal(void 0, nameOrFn, fnOrOptions, maybeOptions);
+  }
+  /**
+   * {@link step} variant that also labels the span with a plugin-only name.
+   * Never checkpointed. See {@link InternalDurableContext}.
+   * @internal
+   */
+  _stepWithPluginOperationName(pluginOperationName, nameOrFn, fnOrOptions, maybeOptions) {
+    return this.stepInternal(pluginOperationName, nameOrFn, fnOrOptions, maybeOptions);
+  }
+  stepInternal(pluginOperationName, nameOrFn, fnOrOptions, maybeOptions) {
     validateContextUsage(this._stepPrefix, "step", this._executionContext.terminationManager);
     return this.withDurableModeManagement(() => {
-      const stepHandler = createStepHandler(this._executionContext, this.checkpoint, this.lambdaContext, this.createStepId.bind(this), this.durableLogger, this._parentId, () => this._defaultSerdes, this.durableExecution.plugin);
+      const stepHandler = createStepHandler(this._executionContext, this.checkpoint, this.lambdaContext, this.createStepId.bind(this), this.durableLogger, this._parentId, () => this._defaultSerdes, this.durableExecution.plugin, pluginOperationName);
       return stepHandler(nameOrFn, fnOrOptions, maybeOptions);
     });
   }
@@ -3313,9 +3504,20 @@ var DurableContextImpl = class {
     }
   }
   createCallback(nameOrConfig, maybeConfig) {
+    return this.createCallbackInternal(void 0, nameOrConfig, maybeConfig);
+  }
+  /**
+   * {@link createCallback} variant that also labels the span with a
+   * plugin-only name. Never checkpointed. See {@link InternalDurableContext}.
+   * @internal
+   */
+  _createCallbackWithPluginOperationName(pluginOperationName, nameOrConfig, maybeConfig) {
+    return this.createCallbackInternal(pluginOperationName, nameOrConfig, maybeConfig);
+  }
+  createCallbackInternal(pluginOperationName, nameOrConfig, maybeConfig) {
     validateContextUsage(this._stepPrefix, "createCallback", this._executionContext.terminationManager);
     return this.withDurableModeManagement(() => {
-      const callbackFactory = createCallback(this._executionContext, this.checkpoint, this.createStepId.bind(this), this.checkAndUpdateReplayMode.bind(this), this._parentId, () => this._defaultCallbackDeserializer, this.durableExecution.plugin);
+      const callbackFactory = createCallback(this._executionContext, this.checkpoint, this.createStepId.bind(this), this.checkAndUpdateReplayMode.bind(this), this._parentId, () => this._defaultCallbackDeserializer, this.durableExecution.plugin, pluginOperationName);
       return callbackFactory(nameOrConfig, maybeConfig);
     });
   }
@@ -4151,7 +4353,7 @@ function formatDurableLogData(level, logData, enrichLogContext, ...messageParams
     executionArn: logData.executionArn
   };
   const tenantId = logData.tenantId;
-  if (tenantId != void 0 && tenantId != null) {
+  if (tenantId != null) {
     result.tenantId = tenantId;
   }
   if (logData.operationId !== void 0) {
@@ -4324,7 +4526,7 @@ function isInLambdaRuntime() {
 }
 var isRuntimeBundled = isInLambdaRuntime();
 var SDK_NAME = "aws-durable-execution-sdk-js";
-var baseVersion = "2.3.0";
+var baseVersion = "2.3.1";
 var SDK_VERSION = isRuntimeBundled ? `${baseVersion}-bundled` : baseVersion;
 var lambdaModulePromise;
 var defaultLambdaClient;
@@ -4893,52 +5095,41 @@ async function runHandler(event, context, executionContext, durableExecutionMode
         log("\u{1F6D1}", "Serdes failed - terminating Lambda execution");
         throw new SerdesFailedError(result.message);
       }
-      if (resultType === "termination" && result.reason === TerminationReason.CONTEXT_VALIDATION_ERROR) {
-        log("\u{1F6D1}", "Context validation error - returning FAILED status");
-        const response = {
-          Status: InvocationStatus.FAILED,
-          Error: createErrorObjectFromError(result.error || new Error(result.message))
-        };
-        await plugin.onInvocationEnd?.({
-          ...invocationBaseInfo,
-          status: PluginInvocationStatus.FAILED,
-          executionInput: customerHandlerEvent,
-          executionError: result.error || new Error(result.message),
-          executionResult: void 0,
-          operations: toOperationInfoMap(executionContext._stepData)
+      if (resultType === "termination") {
+        if (classifyTermination(result.reason) === "suspend") {
+          log("\u{1F6D1}", "Returning termination response", {
+            reason: result.reason
+          });
+          await plugin.onInvocationEnd?.({
+            ...invocationBaseInfo,
+            status: PluginInvocationStatus.PENDING,
+            executionInput: customerHandlerEvent,
+            executionResult: void 0,
+            executionError: void 0,
+            operations: toOperationInfoMap(executionContext._stepData)
+          });
+          return {
+            Status: InvocationStatus.PENDING
+          };
+        }
+        const error = result.error ?? new Error(result.message);
+        log("\u{1F6D1}", `Terminated with ${result.reason} - returning FAILED status`, {
+          message: result.message
         });
-        return response;
-      }
-      if (resultType === "termination" && result.reason === TerminationReason.CONFIG_VALIDATION_ERROR) {
-        log("\u{1F6D1}", "Config validation error - returning FAILED status");
         const response = {
           Status: InvocationStatus.FAILED,
-          Error: createErrorObjectFromError(result.error || new Error(result.message))
+          Error: createErrorObjectFromError(error)
         };
         await plugin.onInvocationEnd?.({
           ...invocationBaseInfo,
           status: PluginInvocationStatus.FAILED,
           executionInput: customerHandlerEvent,
-          executionError: result.error || new Error(result.message),
+          executionError: error,
           executionResult: void 0,
           operations: toOperationInfoMap(executionContext._stepData)
         });
         return response;
       }
-      if (resultType === "termination") {
-        log("\u{1F6D1}", "Returning termination response");
-        await plugin.onInvocationEnd?.({
-          ...invocationBaseInfo,
-          status: PluginInvocationStatus.PENDING,
-          executionInput: customerHandlerEvent,
-          executionResult: void 0,
-          executionError: void 0,
-          operations: toOperationInfoMap(executionContext._stepData)
-        });
-        return {
-          Status: InvocationStatus.PENDING
-        };
-      }
       log("\u2705", "Returning normal completion response");
       const serializedResult = JSON.stringify(result);
       const serializedSize = new TextEncoder().encode(serializedResult).length;

package/lib/index.js

@@ -50,7 +50,7 @@ const detector_function_1 = require("./funcs/detector-function");
  * every stable stack in the account and region is inspected.
  */
 class CloudformationStackDriftDetector extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cloudformation-stack-drift-detector.CloudformationStackDriftDetector", version: "0.1.4" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cloudformation-stack-drift-detector.CloudformationStackDriftDetector", version: "0.1.5" };
     /**
      * SNS topic that receives drift notifications.
      */

package/package.json

@@ -58,14 +58,14 @@
     "eslint": "^9",
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-import": "^2.32.0",
-    "jest": "^30.5.0",
+    "jest": "^30.5.1",
     "jest-junit": "^17",
     "jsii": "6.0.x",
     "jsii-diff": "^1.140.0",
     "jsii-docgen": "^10.5.0",
     "jsii-pacmak": "^1.140.0",
     "jsii-rosetta": "6.0.x",
-    "projen": "^0.103.11",
+    "projen": "^0.103.20",
     "ts-jest": "^29.4.12",
     "ts-node": "^10.9.2",
     "typescript": "6.0.x"
@@ -99,7 +99,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.4",
+  "version": "0.1.5",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [