@aws-cdk/toolkit-lib 1.27.0 → 1.29.0

package/lib/api/stack-events/stack-event-poller.d.ts

@@ -1,6 +1,7 @@
 import type { StackEvent } from '@aws-sdk/client-cloudformation';
 import type { ResourceError } from './resource-errors';
 import { ResourceErrors } from './resource-errors';
+import type { ResourceDeleteFailure } from '../../toolkit/types';
 import type { ICloudFormationClient } from '../aws-auth/private';
 export interface StackEventPollerProps {
     /**
@@ -109,6 +110,11 @@ export declare class StackEventPoller {
      * A record of the errors we've seen
      */
     readonly errors: ResourceErrors;
+    /**
+     * Resources that received DELETE_FAILED during a stack update.
+     * CloudFormation skips these and completes the update anyway.
+     */
+    readonly deleteFailures: ResourceDeleteFailure[];
     private readonly eventIds;
     private readonly nestedStackPollers;
     constructor(cfn: ICloudFormationClient, props: StackEventPollerProps);
@@ -127,6 +133,7 @@ export declare class StackEventPoller {
      * invocations to `poll` will return *newer* events (also in old-to-new order).
      */
     poll(): Promise<ResourceEvent[]>;
+    private updateDeleteFailures;
     private doPoll;
     /**
      * On the CREATE_IN_PROGRESS, UPDATE_IN_PROGRESS, DELETE_IN_PROGRESS event of a nested stack, poll the nested stack updates

package/lib/api/stack-events/stack-event-poller.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StackEventPoller = exports.PollRange = void 0;
+const client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
 const resource_errors_1 = require("./resource-errors");
 const util_1 = require("../../util");
 class PollRange {
@@ -96,6 +97,11 @@ class StackEventPoller {
      * A record of the errors we've seen
      */
     errors = new resource_errors_1.ResourceErrors();
+    /**
+     * Resources that received DELETE_FAILED during a stack update.
+     * CloudFormation skips these and completes the update anyway.
+     */
+    deleteFailures = [];
     eventIds = new Set();
     nestedStackPollers = {};
     constructor(cfn, props) {
@@ -131,8 +137,21 @@ class StackEventPoller {
         events.sort((a, b) => a.event.Timestamp.valueOf() - b.event.Timestamp.valueOf());
         this.events.push(...events);
         this.errors.update(...events);
+        this.updateDeleteFailures(events);
         return events;
     }
+    updateDeleteFailures(events) {
+        for (const { event } of events) {
+            if (event.ResourceStatus === client_cloudformation_1.ResourceStatus.DELETE_FAILED && event.ResourceType !== 'AWS::CloudFormation::Stack') {
+                this.deleteFailures.push({
+                    logicalResourceId: event.LogicalResourceId ?? '',
+                    physicalResourceId: event.PhysicalResourceId,
+                    resourceType: event.ResourceType ?? '',
+                    reason: event.ResourceStatusReason ?? '',
+                });
+            }
+        }
+    }
     async doPoll() {
         // If we already have events and we poll again, we can only get newer events up to
         // events we've already seen. No need to invoke the "oldestEvent" decider again.
@@ -224,4 +243,4 @@ function isStackBeginOperationState(state) {
 function isStackTerminalState(state) {
     return !(state ?? '').endsWith('_IN_PROGRESS');
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-event-poller.js","sourceRoot":"","sources":["stack-event-poller.ts"],"names":[],"mappings":"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","sourcesContent":["import type { StackEvent } from '@aws-sdk/client-cloudformation';\nimport type { ResourceError } from './resource-errors';\nimport { ResourceErrors } from './resource-errors';\nimport { formatErrorMessage, isRootStackEvent } from '../../util';\nimport type { ICloudFormationClient } from '../aws-auth/private';\n\nexport interface StackEventPollerProps {\n  /**\n   * The stack to poll\n   */\n  readonly stackArn: string;\n\n  /**\n   * IDs of parent stacks of this resource, in case of resources in nested stacks\n   */\n  readonly parentStackLogicalIds?: string[];\n\n  /**\n   * A configurable algorithm to indicate when we should stop consuming the event stream.\n   *\n   * The initialPollRange object will be called on the first occurrence of\n   * polling.  It will be shown all events in a chunk in turn, newest-to-oldest,\n   * and should decide the oldest event we're still interested in. We will not\n   * go back further consuming the event stream.\n   *\n   * On subsequent polls, we will use the events we've already seen to decide when to stop\n   * polling.\n   */\n  readonly initialPollRange: IPollRange;\n}\n\nexport interface IPollRange {\n  /**\n   * Whether polling should stop on seeing this event\n   */\n  shouldStop(event: ResourceEvent): 'stop-include' | 'stop-exclude' | 'continue';\n}\n\nexport abstract class PollRange {\n  /**\n   * Only include events since than a given time\n   */\n  public static sinceTimestamp(startTime: number): IPollRange {\n    return {\n      shouldStop(event) {\n        return event.event.Timestamp!.valueOf() < startTime ? 'stop-exclude' : 'continue';\n      },\n    };\n  }\n\n  /**\n   * Stop when we see the root stack entering this status\n   *\n   * Should be something like `CREATE_IN_PROGRESS`, `UPDATE_IN_PROGRESS`,\n   * `DELETE_IN_PROGRESS, `ROLLBACK_IN_PROGRESS`.\n   */\n  public static sinceStackStatus(statuses: string[]): IPollRange {\n    return {\n      shouldStop(event) {\n        return event.isRootStackEvent && statuses.includes(event.event.ResourceStatus ?? '') ? 'stop-include' : 'continue';\n      },\n    };\n  }\n\n  /**\n   * Stop when we see events that belong to a different operation\n   *\n   * Records the first OperationId, and stops as soon as we see events that don't have it anymore.\n   */\n  public static mostRecentOperation(): IPollRange {\n    let operationId: string | undefined;\n    return {\n      shouldStop(event) {\n        if (operationId === undefined) {\n          operationId = event.event.OperationId;\n          return 'continue';\n        }\n\n        return event.event.OperationId === operationId ? 'continue' : 'stop-exclude';\n      },\n    };\n  }\n\n  /**\n   * A poll range decider that always returns 'continue', consuming the entire CFN event stream.\n   */\n  public static consumeAll(): IPollRange {\n    return {\n      shouldStop() {\n        return 'continue';\n      },\n    };\n  }\n}\n\nexport interface ResourceEvent {\n  /**\n   * The Stack Event as received from CloudFormation\n   */\n  readonly event: StackEvent;\n\n  /**\n   * IDs of parent stacks of the resource, in case of resources in nested stacks\n   */\n  readonly parentStackLogicalIds: string[];\n\n  /**\n   * Whether this event regards the root stack\n   *\n   * @default false\n   */\n  readonly isRootStackEvent?: boolean;\n}\n\n/**\n * Poll for stack events, potentially multiple times as new events come in over time\n *\n * Includes events from nested stacks.\n *\n * Polling may happen in multiple bursts, and every burst consumes events from newest-to-oldest\n * from the stack events API, so events are consumed in the following order:\n *\n * ```\n * CONSUMING\n *\n * stack events   (new) z y x w v u t s r q p o n m l k j i h g f e d c b a (old)\n * bursts                                          [   poll() #1    ]\n *                                   [  poll() #2   ]               ^\n *                     [  poll() #3   ]                      initialPollRange\n *                                                          decides to stop here\n * ```\n *\n * Events are sorted old-to-new before being returned, so the events returned by each\n * poll are:\n *\n * ```\n * poll() #1 => [e f g h i j k l]\n * poll() #2 => [m n o p q r s]\n * poll() #3 => [t u v w x y z]\n * ```\n *\n */\nexport class StackEventPoller {\n  /**\n   * All events we've seen so far\n   */\n  public readonly events: ResourceEvent[] = [];\n  public complete: boolean = false;\n\n  /**\n   * A record of the errors we've seen\n   */\n  public readonly errors = new ResourceErrors();\n\n  private readonly eventIds = new Set<string>();\n  private readonly nestedStackPollers: Record<string, StackEventPoller> = {};\n\n  constructor(\n    private readonly cfn: ICloudFormationClient,\n    private readonly props: StackEventPollerProps,\n  ) {\n  }\n\n  /**\n   * From all accumulated events, return only the errors\n   */\n  public get resourceErrors(): ReadonlyArray<ResourceError> {\n    return this.errors.all;\n  }\n\n  /**\n   * Poll for new stack events\n   *\n   * Will read all events that are available up until the oldest events\n   * indicated by the constructor filters, or until it encounters events that it\n   * has already read before.\n   *\n   * Recurses into nested stacks, and returns events old-to-new. Multiple\n   * invocations to `poll` will return *newer* events (also in old-to-new order).\n   */\n  public async poll(): Promise<ResourceEvent[]> {\n    const events: ResourceEvent[] = await this.doPoll();\n\n    // Also poll all nested stacks we're currently tracking\n    for (const [logicalId, poller] of Object.entries(this.nestedStackPollers)) {\n      events.push(...(await poller.poll()));\n      if (poller.complete) {\n        delete this.nestedStackPollers[logicalId];\n      }\n    }\n\n    // Return what we have so far\n    events.sort((a, b) => a.event.Timestamp!.valueOf() - b.event.Timestamp!.valueOf());\n    this.events.push(...events);\n\n    this.errors.update(...events);\n\n    return events;\n  }\n\n  private async doPoll(): Promise<ResourceEvent[]> {\n    // If we already have events and we poll again, we can only get newer events up to\n    // events we've already seen. No need to invoke the \"oldestEvent\" decider again.\n    const stopDecider = this.eventIds.size > 0 ? PollRange.consumeAll() : this.props.initialPollRange;\n\n    const events: ResourceEvent[] = [];\n    try {\n      let nextToken: string | undefined;\n      let finished = false;\n\n      while (!finished) {\n        const page = await this.cfn.describeStackEvents({ StackName: this.props.stackArn, NextToken: nextToken });\n        for (const event of page?.StackEvents ?? []) {\n          // Already seen this one\n          if (this.eventIds.has(event.EventId!)) {\n            return events;\n          }\n\n          const isParentStackEvent = isRootStackEvent(event);\n          // Fresh event\n          const resEvent: ResourceEvent = {\n            event: event,\n            parentStackLogicalIds: this.props.parentStackLogicalIds ?? [],\n            isRootStackEvent: isParentStackEvent,\n          };\n\n          // Make a stop decision\n          const stopDecision = stopDecider.shouldStop(resEvent);\n          if (stopDecision === 'stop-exclude') {\n            return events;\n          }\n\n          this.eventIds.add(event.EventId!);\n\n          events.push(resEvent);\n\n          if (stopDecision === 'stop-include') {\n            return events;\n          }\n\n          if (\n            !isParentStackEvent &&\n              event.ResourceType === 'AWS::CloudFormation::Stack' &&\n              isStackBeginOperationState(event.ResourceStatus)\n          ) {\n            // If the event is not for `this` stack and has a physical resource Id, recursively call for events in the nested stack\n            this.trackNestedStack(event, [...(this.props.parentStackLogicalIds ?? []), event.LogicalResourceId ?? '']);\n          }\n\n          if (isParentStackEvent && isStackTerminalState(event.ResourceStatus)) {\n            this.complete = true;\n          }\n        }\n\n        nextToken = page?.NextToken;\n        if (nextToken === undefined) {\n          finished = true;\n        }\n      }\n    } catch (e: any) {\n      // CFN returns the input exactly as provided by us to the `DescribeStackEvents` api call\n      if (!(e.name === 'ValidationError' && formatErrorMessage(e) === `Stack [${this.props.stackArn}] does not exist`)) {\n        throw e;\n      }\n    }\n\n    return events;\n  }\n\n  /**\n   * On the CREATE_IN_PROGRESS, UPDATE_IN_PROGRESS, DELETE_IN_PROGRESS event of a nested stack, poll the nested stack updates\n   */\n  private trackNestedStack(event: StackEvent, parentStackLogicalIds: string[]) {\n    const logicalId = event.LogicalResourceId;\n    const physicalResourceId = event.PhysicalResourceId;\n\n    // The CREATE_IN_PROGRESS event for a Nested Stack is emitted twice; first without a PhysicalResourceId\n    // and then with. Ignore this event if we don't have that property yet.\n    //\n    // (At this point, I also don't trust that logicalId is always going to be there so validate that as well)\n    if (!logicalId || !physicalResourceId) {\n      return;\n    }\n\n    if (!this.nestedStackPollers[logicalId]) {\n      this.nestedStackPollers[logicalId] = new StackEventPoller(this.cfn, {\n        stackArn: physicalResourceId,\n        parentStackLogicalIds: parentStackLogicalIds,\n        initialPollRange: PollRange.sinceTimestamp(event.Timestamp!.valueOf()),\n      });\n    }\n  }\n}\n\nfunction isStackBeginOperationState(state: string | undefined) {\n  return [\n    'CREATE_IN_PROGRESS',\n    'UPDATE_IN_PROGRESS',\n    'DELETE_IN_PROGRESS',\n    'UPDATE_ROLLBACK_IN_PROGRESS',\n    'ROLLBACK_IN_PROGRESS',\n  ].includes(state ?? '');\n}\n\nfunction isStackTerminalState(state: string | undefined) {\n  return !(state ?? '').endsWith('_IN_PROGRESS');\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-event-poller.js","sourceRoot":"","sources":["stack-event-poller.ts"],"names":[],"mappings":"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","sourcesContent":["import type { StackEvent } from '@aws-sdk/client-cloudformation';\nimport { ResourceStatus } from '@aws-sdk/client-cloudformation';\nimport type { ResourceError } from './resource-errors';\nimport { ResourceErrors } from './resource-errors';\nimport type { ResourceDeleteFailure } from '../../toolkit/types';\nimport { formatErrorMessage, isRootStackEvent } from '../../util';\nimport type { ICloudFormationClient } from '../aws-auth/private';\n\nexport interface StackEventPollerProps {\n  /**\n   * The stack to poll\n   */\n  readonly stackArn: string;\n\n  /**\n   * IDs of parent stacks of this resource, in case of resources in nested stacks\n   */\n  readonly parentStackLogicalIds?: string[];\n\n  /**\n   * A configurable algorithm to indicate when we should stop consuming the event stream.\n   *\n   * The initialPollRange object will be called on the first occurrence of\n   * polling.  It will be shown all events in a chunk in turn, newest-to-oldest,\n   * and should decide the oldest event we're still interested in. We will not\n   * go back further consuming the event stream.\n   *\n   * On subsequent polls, we will use the events we've already seen to decide when to stop\n   * polling.\n   */\n  readonly initialPollRange: IPollRange;\n}\n\nexport interface IPollRange {\n  /**\n   * Whether polling should stop on seeing this event\n   */\n  shouldStop(event: ResourceEvent): 'stop-include' | 'stop-exclude' | 'continue';\n}\n\nexport abstract class PollRange {\n  /**\n   * Only include events since than a given time\n   */\n  public static sinceTimestamp(startTime: number): IPollRange {\n    return {\n      shouldStop(event) {\n        return event.event.Timestamp!.valueOf() < startTime ? 'stop-exclude' : 'continue';\n      },\n    };\n  }\n\n  /**\n   * Stop when we see the root stack entering this status\n   *\n   * Should be something like `CREATE_IN_PROGRESS`, `UPDATE_IN_PROGRESS`,\n   * `DELETE_IN_PROGRESS, `ROLLBACK_IN_PROGRESS`.\n   */\n  public static sinceStackStatus(statuses: string[]): IPollRange {\n    return {\n      shouldStop(event) {\n        return event.isRootStackEvent && statuses.includes(event.event.ResourceStatus ?? '') ? 'stop-include' : 'continue';\n      },\n    };\n  }\n\n  /**\n   * Stop when we see events that belong to a different operation\n   *\n   * Records the first OperationId, and stops as soon as we see events that don't have it anymore.\n   */\n  public static mostRecentOperation(): IPollRange {\n    let operationId: string | undefined;\n    return {\n      shouldStop(event) {\n        if (operationId === undefined) {\n          operationId = event.event.OperationId;\n          return 'continue';\n        }\n\n        return event.event.OperationId === operationId ? 'continue' : 'stop-exclude';\n      },\n    };\n  }\n\n  /**\n   * A poll range decider that always returns 'continue', consuming the entire CFN event stream.\n   */\n  public static consumeAll(): IPollRange {\n    return {\n      shouldStop() {\n        return 'continue';\n      },\n    };\n  }\n}\n\nexport interface ResourceEvent {\n  /**\n   * The Stack Event as received from CloudFormation\n   */\n  readonly event: StackEvent;\n\n  /**\n   * IDs of parent stacks of the resource, in case of resources in nested stacks\n   */\n  readonly parentStackLogicalIds: string[];\n\n  /**\n   * Whether this event regards the root stack\n   *\n   * @default false\n   */\n  readonly isRootStackEvent?: boolean;\n}\n\n/**\n * Poll for stack events, potentially multiple times as new events come in over time\n *\n * Includes events from nested stacks.\n *\n * Polling may happen in multiple bursts, and every burst consumes events from newest-to-oldest\n * from the stack events API, so events are consumed in the following order:\n *\n * ```\n * CONSUMING\n *\n * stack events   (new) z y x w v u t s r q p o n m l k j i h g f e d c b a (old)\n * bursts                                          [   poll() #1    ]\n *                                   [  poll() #2   ]               ^\n *                     [  poll() #3   ]                      initialPollRange\n *                                                          decides to stop here\n * ```\n *\n * Events are sorted old-to-new before being returned, so the events returned by each\n * poll are:\n *\n * ```\n * poll() #1 => [e f g h i j k l]\n * poll() #2 => [m n o p q r s]\n * poll() #3 => [t u v w x y z]\n * ```\n *\n */\nexport class StackEventPoller {\n  /**\n   * All events we've seen so far\n   */\n  public readonly events: ResourceEvent[] = [];\n  public complete: boolean = false;\n\n  /**\n   * A record of the errors we've seen\n   */\n  public readonly errors = new ResourceErrors();\n\n  /**\n   * Resources that received DELETE_FAILED during a stack update.\n   * CloudFormation skips these and completes the update anyway.\n   */\n  public readonly deleteFailures: ResourceDeleteFailure[] = [];\n\n  private readonly eventIds = new Set<string>();\n  private readonly nestedStackPollers: Record<string, StackEventPoller> = {};\n\n  constructor(\n    private readonly cfn: ICloudFormationClient,\n    private readonly props: StackEventPollerProps,\n  ) {\n  }\n\n  /**\n   * From all accumulated events, return only the errors\n   */\n  public get resourceErrors(): ReadonlyArray<ResourceError> {\n    return this.errors.all;\n  }\n\n  /**\n   * Poll for new stack events\n   *\n   * Will read all events that are available up until the oldest events\n   * indicated by the constructor filters, or until it encounters events that it\n   * has already read before.\n   *\n   * Recurses into nested stacks, and returns events old-to-new. Multiple\n   * invocations to `poll` will return *newer* events (also in old-to-new order).\n   */\n  public async poll(): Promise<ResourceEvent[]> {\n    const events: ResourceEvent[] = await this.doPoll();\n\n    // Also poll all nested stacks we're currently tracking\n    for (const [logicalId, poller] of Object.entries(this.nestedStackPollers)) {\n      events.push(...(await poller.poll()));\n      if (poller.complete) {\n        delete this.nestedStackPollers[logicalId];\n      }\n    }\n\n    // Return what we have so far\n    events.sort((a, b) => a.event.Timestamp!.valueOf() - b.event.Timestamp!.valueOf());\n    this.events.push(...events);\n\n    this.errors.update(...events);\n    this.updateDeleteFailures(events);\n\n    return events;\n  }\n\n  private updateDeleteFailures(events: ResourceEvent[]) {\n    for (const { event } of events) {\n      if (event.ResourceStatus === ResourceStatus.DELETE_FAILED && event.ResourceType !== 'AWS::CloudFormation::Stack') {\n        this.deleteFailures.push({\n          logicalResourceId: event.LogicalResourceId ?? '',\n          physicalResourceId: event.PhysicalResourceId,\n          resourceType: event.ResourceType ?? '',\n          reason: event.ResourceStatusReason ?? '',\n        });\n      }\n    }\n  }\n\n  private async doPoll(): Promise<ResourceEvent[]> {\n    // If we already have events and we poll again, we can only get newer events up to\n    // events we've already seen. No need to invoke the \"oldestEvent\" decider again.\n    const stopDecider = this.eventIds.size > 0 ? PollRange.consumeAll() : this.props.initialPollRange;\n\n    const events: ResourceEvent[] = [];\n    try {\n      let nextToken: string | undefined;\n      let finished = false;\n\n      while (!finished) {\n        const page = await this.cfn.describeStackEvents({ StackName: this.props.stackArn, NextToken: nextToken });\n        for (const event of page?.StackEvents ?? []) {\n          // Already seen this one\n          if (this.eventIds.has(event.EventId!)) {\n            return events;\n          }\n\n          const isParentStackEvent = isRootStackEvent(event);\n          // Fresh event\n          const resEvent: ResourceEvent = {\n            event: event,\n            parentStackLogicalIds: this.props.parentStackLogicalIds ?? [],\n            isRootStackEvent: isParentStackEvent,\n          };\n\n          // Make a stop decision\n          const stopDecision = stopDecider.shouldStop(resEvent);\n          if (stopDecision === 'stop-exclude') {\n            return events;\n          }\n\n          this.eventIds.add(event.EventId!);\n\n          events.push(resEvent);\n\n          if (stopDecision === 'stop-include') {\n            return events;\n          }\n\n          if (\n            !isParentStackEvent &&\n              event.ResourceType === 'AWS::CloudFormation::Stack' &&\n              isStackBeginOperationState(event.ResourceStatus)\n          ) {\n            // If the event is not for `this` stack and has a physical resource Id, recursively call for events in the nested stack\n            this.trackNestedStack(event, [...(this.props.parentStackLogicalIds ?? []), event.LogicalResourceId ?? '']);\n          }\n\n          if (isParentStackEvent && isStackTerminalState(event.ResourceStatus)) {\n            this.complete = true;\n          }\n        }\n\n        nextToken = page?.NextToken;\n        if (nextToken === undefined) {\n          finished = true;\n        }\n      }\n    } catch (e: any) {\n      // CFN returns the input exactly as provided by us to the `DescribeStackEvents` api call\n      if (!(e.name === 'ValidationError' && formatErrorMessage(e) === `Stack [${this.props.stackArn}] does not exist`)) {\n        throw e;\n      }\n    }\n\n    return events;\n  }\n\n  /**\n   * On the CREATE_IN_PROGRESS, UPDATE_IN_PROGRESS, DELETE_IN_PROGRESS event of a nested stack, poll the nested stack updates\n   */\n  private trackNestedStack(event: StackEvent, parentStackLogicalIds: string[]) {\n    const logicalId = event.LogicalResourceId;\n    const physicalResourceId = event.PhysicalResourceId;\n\n    // The CREATE_IN_PROGRESS event for a Nested Stack is emitted twice; first without a PhysicalResourceId\n    // and then with. Ignore this event if we don't have that property yet.\n    //\n    // (At this point, I also don't trust that logicalId is always going to be there so validate that as well)\n    if (!logicalId || !physicalResourceId) {\n      return;\n    }\n\n    if (!this.nestedStackPollers[logicalId]) {\n      this.nestedStackPollers[logicalId] = new StackEventPoller(this.cfn, {\n        stackArn: physicalResourceId,\n        parentStackLogicalIds: parentStackLogicalIds,\n        initialPollRange: PollRange.sinceTimestamp(event.Timestamp!.valueOf()),\n      });\n    }\n  }\n}\n\nfunction isStackBeginOperationState(state: string | undefined) {\n  return [\n    'CREATE_IN_PROGRESS',\n    'UPDATE_IN_PROGRESS',\n    'DELETE_IN_PROGRESS',\n    'UPDATE_ROLLBACK_IN_PROGRESS',\n    'ROLLBACK_IN_PROGRESS',\n  ].includes(state ?? '');\n}\n\nfunction isStackTerminalState(state: string | undefined) {\n  return !(state ?? '').endsWith('_IN_PROGRESS');\n}\n"]}

package/lib/api/validate/validate-formatting.d.ts

@@ -0,0 +1,5 @@
+import type { ValidateResult } from '../../actions/validate';
+import type { ActionLessMessage } from '../io/private';
+export declare function hostMessageFromValidation(result: ValidateResult): ActionLessMessage<any>;
+export declare function formatValidateResult(result: ValidateResult): string;
+//# sourceMappingURL=validate-formatting.d.ts.map

package/lib/api/validate/validate-formatting.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hostMessageFromValidation = hostMessageFromValidation;
+exports.formatValidateResult = formatValidateResult;
+const path = require("node:path");
+const chalk = require("chalk");
+const private_1 = require("../io/private");
+// Matches C0 control chars (except \t and \n), DEL, and CSI (8-bit mode).
+// Strips ANSI escape sequences, carriage returns, backspaces, BEL, and
+// bidirectional overrides that could spoof terminal output.
+const CONTROL_CHARS = /[\x00-\x08\x0B-\x1F\x7F\x9B]/g;
+function sanitize(s) {
+    return (s ?? '').replace(CONTROL_CHARS, '�');
+}
+const SEVERITY_ORDER = {
+    fatal: 0,
+    error: 1,
+    warning: 2,
+    info: 3,
+};
+function hostMessageFromValidation(result) {
+    // Always emit at info level so the CLI IoHost doesn't wrap the entire output
+    // in a single color. The formatter handles per-severity coloring internally.
+    // Consumers detect failure via the structured `data.conclusion` field or exit code.
+    return private_1.IO.CDK_TOOLKIT_I9600.msg(formatValidateResult(result), result);
+}
+function formatValidateResult(result) {
+    const violations = flattenViolations(result.pluginReports);
+    if (violations.length === 0) {
+        return '\nPolicy validation passed. No problems found.';
+    }
+    violations.sort((a, b) => {
+        const aOrder = SEVERITY_ORDER[a.severity.toLowerCase()] ?? 4;
+        const bOrder = SEVERITY_ORDER[b.severity.toLowerCase()] ?? 4;
+        return aOrder - bOrder;
+    });
+    const title = result.title ?? 'Validation Report';
+    const blocks = violations.map((v) => formatViolationBlock(v));
+    return `\n${title}\n${'-'.repeat(title.length)}\n\n${blocks.join('\n\n')}`;
+}
+function flattenViolations(pluginReports) {
+    const result = [];
+    for (const report of pluginReports) {
+        const pluginName = report.pluginName;
+        for (const violation of report.violations) {
+            const severity = normalizeSeverity(violation.severity);
+            for (const construct of violation.violatingConstructs) {
+                result.push({ severity, description: violation.description, ruleName: violation.ruleName, pluginName, construct });
+            }
+        }
+    }
+    return result;
+}
+function normalizeSeverity(severity) {
+    if (!severity)
+        return 'Warning';
+    const lower = severity.toLowerCase();
+    if (lower === 'fatal')
+        return 'Fatal';
+    if (lower === 'error')
+        return 'Error';
+    if (lower === 'warning')
+        return 'Warning';
+    if (lower === 'info')
+        return 'Info';
+    const safe = sanitize(severity);
+    return safe.charAt(0).toUpperCase() + safe.slice(1);
+}
+function formatViolationBlock(v) {
+    const lines = [];
+    const location = getLeafLocation(v.construct.stackTraces);
+    if (location) {
+        lines.push(chalk.underline(sanitize(location)));
+    }
+    const severityColor = getSeverityColor(v.severity);
+    const description = stripAckTag(sanitize(v.description));
+    const severityAndDesc = severityColor(chalk.bold(`${v.severity}: ${description}`));
+    lines.push(`${severityAndDesc} ${sanitize(v.pluginName)}`);
+    const constructInfo = formatConstructInfo(v.construct);
+    lines.push(`   ${constructInfo}`);
+    if (v.severity.toLowerCase() !== 'fatal') {
+        const ackId = `${sanitize(v.pluginName)}::${sanitize(v.ruleName)}`.replace(/ /g, '-');
+        lines.push(`   Acknowledge '${ackId}'`);
+    }
+    return lines.join('\n');
+}
+function getSeverityColor(severity) {
+    switch (severity.toLowerCase()) {
+        case 'fatal': return chalk.red;
+        case 'error': return chalk.ansi256(208);
+        case 'warning': return chalk.yellow;
+        default: return chalk.blue;
+    }
+}
+function formatConstructInfo(construct) {
+    const parts = [];
+    const logicalId = sanitize(construct.cloudFormationResource?.logicalId);
+    if (construct.constructPath) {
+        const cPath = sanitize(construct.constructPath);
+        parts.push(logicalId ? `${chalk.bold(cPath)} (${logicalId})` : chalk.bold(cPath));
+    }
+    else if (logicalId) {
+        parts.push(chalk.bold(logicalId));
+    }
+    if (construct.constructFqn) {
+        parts.push(sanitize(construct.constructFqn));
+    }
+    return parts.join(' ');
+}
+function stripAckTag(description) {
+    return description.replace(/\s*\[ack:\s*[^\]]+\]\s*/g, '').trim();
+}
+function getLeafLocation(stackTraces) {
+    if (!stackTraces || stackTraces.length === 0)
+        return undefined;
+    const lastTrace = stackTraces[stackTraces.length - 1];
+    const frames = lastTrace.split('\n');
+    if (frames.length === 0)
+        return undefined;
+    // Find the first frame that's user code (not in node_modules or aws-cdk-lib)
+    const userFrame = frames.find(f => !f.includes('node_modules') && !f.includes('aws-cdk-lib'));
+    const frame = (userFrame ?? frames[0]).trim();
+    const match = frame.match(/\((.+)\)$/) || frame.match(/at\s+(.+)$/);
+    const location = match ? match[1] : frame;
+    return path.isAbsolute(location.split(':')[0]) ? path.relative(process.cwd(), location) : location;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validate-formatting.js","sourceRoot":"","sources":["validate-formatting.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'node:path';\nimport type { PluginReportJson, ViolatingConstructJson } from '@aws-cdk/cloud-assembly-schema';\nimport * as chalk from 'chalk';\nimport type { ValidateResult } from '../../actions/validate';\nimport type { ActionLessMessage } from '../io/private';\nimport { IO } from '../io/private';\n\n// Matches C0 control chars (except \\t and \\n), DEL, and CSI (8-bit mode).\n// Strips ANSI escape sequences, carriage returns, backspaces, BEL, and\n// bidirectional overrides that could spoof terminal output.\nconst CONTROL_CHARS = /[\\x00-\\x08\\x0B-\\x1F\\x7F\\x9B]/g;\nfunction sanitize(s: string | undefined): string {\n  return (s ?? '').replace(CONTROL_CHARS, '�');\n}\n\ninterface FlattenedViolation {\n  readonly severity: string;\n  readonly description: string;\n  readonly ruleName: string;\n  readonly pluginName: string;\n  readonly construct: ViolatingConstructJson;\n}\n\nconst SEVERITY_ORDER: Record<string, number> = {\n  fatal: 0,\n  error: 1,\n  warning: 2,\n  info: 3,\n};\n\nexport function hostMessageFromValidation(result: ValidateResult): ActionLessMessage<any> {\n  // Always emit at info level so the CLI IoHost doesn't wrap the entire output\n  // in a single color. The formatter handles per-severity coloring internally.\n  // Consumers detect failure via the structured `data.conclusion` field or exit code.\n  return IO.CDK_TOOLKIT_I9600.msg(formatValidateResult(result), result);\n}\n\nexport function formatValidateResult(result: ValidateResult): string {\n  const violations = flattenViolations(result.pluginReports);\n\n  if (violations.length === 0) {\n    return '\\nPolicy validation passed. No problems found.';\n  }\n\n  violations.sort((a, b) => {\n    const aOrder = SEVERITY_ORDER[a.severity.toLowerCase()] ?? 4;\n    const bOrder = SEVERITY_ORDER[b.severity.toLowerCase()] ?? 4;\n    return aOrder - bOrder;\n  });\n\n  const title = result.title ?? 'Validation Report';\n  const blocks = violations.map((v) => formatViolationBlock(v));\n  return `\\n${title}\\n${'-'.repeat(title.length)}\\n\\n${blocks.join('\\n\\n')}`;\n}\n\nfunction flattenViolations(pluginReports: PluginReportJson[]): FlattenedViolation[] {\n  const result: FlattenedViolation[] = [];\n\n  for (const report of pluginReports) {\n    const pluginName = report.pluginName;\n\n    for (const violation of report.violations) {\n      const severity = normalizeSeverity(violation.severity);\n\n      for (const construct of violation.violatingConstructs) {\n        result.push({ severity, description: violation.description, ruleName: violation.ruleName, pluginName, construct });\n      }\n    }\n  }\n\n  return result;\n}\n\nfunction normalizeSeverity(severity: string | undefined): string {\n  if (!severity) return 'Warning';\n  const lower = severity.toLowerCase();\n  if (lower === 'fatal') return 'Fatal';\n  if (lower === 'error') return 'Error';\n  if (lower === 'warning') return 'Warning';\n  if (lower === 'info') return 'Info';\n  const safe = sanitize(severity);\n  return safe.charAt(0).toUpperCase() + safe.slice(1);\n}\n\nfunction formatViolationBlock(v: FlattenedViolation): string {\n  const lines: string[] = [];\n\n  const location = getLeafLocation(v.construct.stackTraces);\n  if (location) {\n    lines.push(chalk.underline(sanitize(location)));\n  }\n\n  const severityColor = getSeverityColor(v.severity);\n  const description = stripAckTag(sanitize(v.description));\n  const severityAndDesc = severityColor(chalk.bold(`${v.severity}: ${description}`));\n  lines.push(`${severityAndDesc} ${sanitize(v.pluginName)}`);\n\n  const constructInfo = formatConstructInfo(v.construct);\n  lines.push(`   ${constructInfo}`);\n\n  if (v.severity.toLowerCase() !== 'fatal') {\n    const ackId = `${sanitize(v.pluginName)}::${sanitize(v.ruleName)}`.replace(/ /g, '-');\n    lines.push(`   Acknowledge '${ackId}'`);\n  }\n\n  return lines.join('\\n');\n}\n\nfunction getSeverityColor(severity: string): (str: string) => string {\n  switch (severity.toLowerCase()) {\n    case 'fatal': return chalk.red;\n    case 'error': return chalk.ansi256(208);\n    case 'warning': return chalk.yellow;\n    default: return chalk.blue;\n  }\n}\n\nfunction formatConstructInfo(construct: ViolatingConstructJson): string {\n  const parts: string[] = [];\n  const logicalId = sanitize(construct.cloudFormationResource?.logicalId);\n\n  if (construct.constructPath) {\n    const cPath = sanitize(construct.constructPath);\n    parts.push(logicalId ? `${chalk.bold(cPath)} (${logicalId})` : chalk.bold(cPath));\n  } else if (logicalId) {\n    parts.push(chalk.bold(logicalId));\n  }\n\n  if (construct.constructFqn) {\n    parts.push(sanitize(construct.constructFqn));\n  }\n\n  return parts.join(' ');\n}\n\nfunction stripAckTag(description: string): string {\n  return description.replace(/\\s*\\[ack:\\s*[^\\]]+\\]\\s*/g, '').trim();\n}\n\nfunction getLeafLocation(stackTraces: string[] | undefined): string | undefined {\n  if (!stackTraces || stackTraces.length === 0) return undefined;\n  const lastTrace = stackTraces[stackTraces.length - 1];\n  const frames = lastTrace.split('\\n');\n  if (frames.length === 0) return undefined;\n\n  // Find the first frame that's user code (not in node_modules or aws-cdk-lib)\n  const userFrame = frames.find(f => !f.includes('node_modules') && !f.includes('aws-cdk-lib'));\n  const frame = (userFrame ?? frames[0]).trim();\n\n  const match = frame.match(/\\((.+)\\)$/) || frame.match(/at\\s+(.+)$/);\n  const location = match ? match[1] : frame;\n  return path.isAbsolute(location.split(':')[0]) ? path.relative(process.cwd(), location) : location;\n}\n"]}

package/lib/api/work-graph/work-graph-builder.d.ts

@@ -8,6 +8,9 @@ export declare class WorkGraphBuilder {
     /**
      * Default priorities for nodes
      *
+     * Messages have the highest priority to ensure they are emitted as soon as
+     * possible (because they will be used for measuring timings).
+     *
      * Assets builds have higher priority than the other two operations, to make good on our promise that
      * '--prebuild-assets' will actually do assets before stacks (if it can). Unfortunately it is the
      * default :(

package/lib/api/work-graph/work-graph-builder.js

@@ -13,6 +13,9 @@ class WorkGraphBuilder {
     /**
      * Default priorities for nodes
      *
+     * Messages have the highest priority to ensure they are emitted as soon as
+     * possible (because they will be used for measuring timings).
+     *
      * Assets builds have higher priority than the other two operations, to make good on our promise that
      * '--prebuild-assets' will actually do assets before stacks (if it can). Unfortunately it is the
      * default :(
@@ -23,6 +26,7 @@ class WorkGraphBuilder {
         'asset-build': 10,
         'asset-publish': 0,
         'stack': 5,
+        'marker': 100,
     };
     graph;
     ioHelper;
@@ -49,8 +53,35 @@ class WorkGraphBuilder {
     addAsset(parentStack, assetManifestArtifact, assetManifest, asset) {
         // Just the artifact identifier
         const assetId = asset.id.assetId;
-        const buildId = `build-${assetId}-${(0, util_1.contentHashAny)([assetId, asset.genericSource]).substring(0, 10)}`;
-        const publishId = `publish-${assetId}-${(0, util_1.contentHashAny)([assetId, asset.genericDestination]).substring(0, 10)}`;
+        // Build node, contains hash of source (build only once)
+        const sourceHash = (0, util_1.contentHashAny)([assetId, asset.genericSource]).substring(0, 10);
+        const buildId = `build-${assetId}-${sourceHash}`;
+        // Publish node, contains hash of both source and dest
+        const publishId = `publish-${assetId}-${sourceHash}${(0, util_1.contentHashAny)([assetId, asset.genericDestination]).substring(0, 10)}`;
+        // Message to emit when we start on an asset
+        const startId = `start-${assetId}`;
+        if (!this.graph.tryGetNode(startId)) {
+            this.graph.addNodes({
+                type: 'marker',
+                id: startId,
+                dependencies: new Set(),
+                deploymentState: work_graph_types_1.DeploymentState.PENDING,
+                priority: WorkGraphBuilder.PRIORITIES.marker,
+                marker: { type: 'start-asset', asset },
+            });
+        }
+        // Message to emit when we end an asset
+        const endId = `end-${assetId}`;
+        if (!this.graph.tryGetNode(endId)) {
+            this.graph.addNodes({
+                type: 'marker',
+                id: endId,
+                dependencies: new Set(),
+                deploymentState: work_graph_types_1.DeploymentState.PENDING,
+                priority: WorkGraphBuilder.PRIORITIES.marker,
+                marker: { type: 'end-asset', asset },
+            });
+        }
         // Build node only gets added once because they are all the same
         if (!this.graph.tryGetNode(buildId)) {
             const node = {
@@ -58,6 +89,8 @@ class WorkGraphBuilder {
                 id: buildId,
                 note: asset.displayName(false),
                 dependencies: new Set([
+                    // Build depends on the start message having been emitted.
+                    startId,
                     ...this.stackArtifactIds(assetManifestArtifact.dependencies),
                     // If we disable prebuild, then assets inherit (stack) dependencies from their parent stack
                     ...!this.prebuildAssets ? this.stackArtifactIds(onlyStacks(parentStack.dependencies)) : [],
@@ -87,6 +120,8 @@ class WorkGraphBuilder {
                 deploymentState: work_graph_types_1.DeploymentState.PENDING,
                 priority: WorkGraphBuilder.PRIORITIES['asset-publish'],
             });
+            // Every publish node that we add must complete before we fire the "done with publishing this asset" message.
+            this.graph.addDependency(endId, publishId);
         }
         for (const inheritedDep of this.stackArtifactIds(onlyStacks(parentStack.dependencies))) {
             // The asset publish step also depends on the stacks that the parent depends on.
@@ -169,4 +204,4 @@ function stacksFromAssets(artifacts) {
 function onlyStacks(artifacts) {
     return artifacts.filter(x => cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(x));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"work-graph-builder.js","sourceRoot":"","sources":["work-graph-builder.ts"],"names":[],"mappings":";;;AAAA,4DAA6E;AAC7E,qDAAqD;AACrD,6CAAyC;AAEzC,yDAAqD;AACrD,+DAA2D;AAC3D,qCAA4C;AAG5C,MAAa,gBAAgB;IAoBR;IACA;IApBnB;;;;;;;;OAQG;IACI,MAAM,CAAC,UAAU,GAAqC;QAC3D,aAAa,EAAE,EAAE;QACjB,eAAe,EAAE,CAAC;QAClB,OAAO,EAAE,CAAC;KACX,CAAC;IACe,KAAK,CAAY;IACjB,QAAQ,CAAW;IAEpC,YACE,QAAkB,EACD,cAAuB,EACvB,WAAW,EAAE;QADb,mBAAc,GAAd,cAAc,CAAS;QACvB,aAAQ,GAAR,QAAQ,CAAK;QAE9B,IAAI,CAAC,KAAK,GAAG,IAAI,sBAAS,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;QACzC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAEO,QAAQ,CAAC,QAA2C;QAC1D,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;YAClB,IAAI,EAAE,OAAO;YACb,EAAE,EAAE,GAAG,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,EAAE,EAAE;YACpC,YAAY,EAAE,IAAI,GAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC;YAC/E,KAAK,EAAE,QAAQ;YACf,eAAe,EAAE,kCAAe,CAAC,OAAO;YACxC,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,KAAK;SAC5C,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,8CAA8C;IACtC,QAAQ,CAAC,WAA8C,EAAE,qBAAkD,EAAE,aAA4B,EAAE,KAAqB;QACtK,+BAA+B;QAC/B,MAAM,OAAO,GAAG,KAAK,CAAC,EAAE,CAAC,OAAO,CAAC;QAEjC,MAAM,OAAO,GAAG,SAAS,OAAO,IAAI,IAAA,qBAAc,EAAC,CAAC,OAAO,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;QACtG,MAAM,SAAS,GAAG,WAAW,OAAO,IAAI,IAAA,qBAAc,EAAC,CAAC,OAAO,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;QAE/G,gEAAgE;QAChE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;YACpC,MAAM,IAAI,GAAmB;gBAC3B,IAAI,EAAE,aAAa;gBACnB,EAAE,EAAE,OAAO;gBACX,IAAI,EAAE,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC;gBAC9B,YAAY,EAAE,IAAI,GAAG,CAAC;oBACpB,GAAG,IAAI,CAAC,gBAAgB,CAAC,qBAAqB,CAAC,YAAY,CAAC;oBAC5D,2FAA2F;oBAC3F,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE;iBAC3F,CAAC;gBACF,WAAW,EAAE,WAAW;gBACxB,qBAAqB;gBACrB,aAAa;gBACb,KAAK;gBACL,eAAe,EAAE,kCAAe,CAAC,OAAO;gBACxC,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,aAAa,CAAC;aACrD,CAAC;YACF,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC5B,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;QACrD,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;gBAClB,IAAI,EAAE,eAAe;gBACrB,EAAE,EAAE,SAAS;gBACb,IAAI,EAAE,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC;gBAC7B,YAAY,EAAE,IAAI,GAAG,CAAC;oBACpB,OAAO;iBACR,CAAC;gBACF,WAAW;gBACX,qBAAqB;gBACrB,aAAa;gBACb,KAAK;gBACL,eAAe,EAAE,kCAAe,CAAC,OAAO;gBACxC,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,eAAe,CAAC;aACvD,CAAC,CAAC;QACL,CAAC;QAED,KAAK,MAAM,YAAY,IAAI,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC;YACvF,gFAAgF;YAChF,0FAA0F;YAC1F,4FAA4F;YAC5F,yFAAyF;YACzF,6FAA6F;YAC7F,uFAAuF;YACvF,2BAA2B;YAC3B,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;QACpD,CAAC;QAED,kEAAkE;QAClE,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,QAAQ,GAAG,WAAW,CAAC,EAAE,EAAE,EAAE,SAAS,CAAC,CAAC;IAC3E,CAAC;IAEM,KAAK,CAAC,SAAgC;QAC3C,MAAM,YAAY,GAAG,gBAAgB,CAAC,SAAS,CAAC,CAAC;QAEjD,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;YACjC,IAAI,KAAK,CAAC,2BAA2B,CAAC,6BAA6B,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC9E,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;YAC1B,CAAC;iBAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,uBAAuB,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACzE,MAAM,QAAQ,GAAG,8BAAa,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;gBAEvD,KAAK,MAAM,KAAK,IAAI,QAAQ,CAAC,OAAO,EAAE,CAAC;oBACrC,MAAM,WAAW,GAAG,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;oBAC/C,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;wBAC9B,MAAM,IAAI,4BAAY,CAAC,uBAAuB,EAAE,6DAA6D,CAAC,CAAC;oBACjH,CAAC;oBACD,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;gBACxD,CAAC;YACH,CAAC;iBAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,6BAA6B,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACrF,MAAM,QAAQ,GAAG,IAAI,KAAK,CAAC,aAAa,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC;gBACjF,MAAM,WAAW,GAAG,IAAI,gBAAgB,CACtC,IAAI,CAAC,QAAQ,EACb,IAAI,CAAC,cAAc,EACnB,GAAG,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,EAAE,GAAG,CAClC,CAAC,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;gBAC5B,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;YACjC,CAAC;iBAAM,CAAC;gBACN,uBAAuB;YACzB,CAAC;QACH,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,6BAA6B,EAAE,CAAC;QAE3C,wGAAwG;QACxG,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAEhC,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAEO,gBAAgB,CAAC,IAA2B;QAClD,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,2BAA2B,CAAC,6BAA6B,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAClI,CAAC;IAEO,eAAe,CAAC,QAA6B;QACnD,IAAI,CAAC,KAAK,CAAC,2BAA2B,CAAC,6BAA6B,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC/E,MAAM,IAAI,4BAAY,CAAC,qBAAqB,EAAE,2DAA2D,QAAQ,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC;QACxI,CAAC;QACD,OAAO,GAAG,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,EAAE,EAAE,CAAC;IAC1C,CAAC;IAED;;;OAGG;IACK,wBAAwB;QAC9B,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC;QAC7D,KAAK,MAAM,WAAW,IAAI,YAAY,EAAE,CAAC;YACvC,KAAK,MAAM,GAAG,IAAI,WAAW,CAAC,YAAY,EAAE,CAAC;gBAC3C,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,EAAE,WAAW,CAAC,EAAE,CAAC,EAAE,CAAC;oBAC9C,WAAW,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBACvC,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;;AApKH,4CAqKC;AAED,SAAS,gBAAgB,CAAC,SAAgC;IACxD,MAAM,GAAG,GAAG,IAAI,GAAG,EAAkE,CAAC;IACtF,KAAK,MAAM,KAAK,IAAI,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,2BAA2B,CAAC,6BAA6B,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9G,MAAM,cAAc,GAAG,KAAK,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,qBAAqB,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,CAAC;QAChH,KAAK,MAAM,GAAG,IAAI,cAAc,EAAE,CAAC;YACjC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACtB,CAAC;IACH,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,UAAU,CAAC,SAAgC;IAClD,OAAO,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,2BAA2B,CAAC,6BAA6B,CAAC,CAAC,CAAC,CAAC,CAAC;AACnG,CAAC","sourcesContent":["import { AssetManifest, type IManifestEntry } from '@aws-cdk/cdk-assets-lib';\nimport * as cxapi from '@aws-cdk/cloud-assembly-api';\nimport { WorkGraph } from './work-graph';\nimport type { AssetBuildNode, WorkNode } from './work-graph-types';\nimport { DeploymentState } from './work-graph-types';\nimport { ToolkitError } from '../../toolkit/toolkit-error';\nimport { contentHashAny } from '../../util';\nimport type { IoHelper } from '../io/private';\n\nexport class WorkGraphBuilder {\n  /**\n   * Default priorities for nodes\n   *\n   * Assets builds have higher priority than the other two operations, to make good on our promise that\n   * '--prebuild-assets' will actually do assets before stacks (if it can). Unfortunately it is the\n   * default :(\n   *\n   * But between stack dependencies and publish dependencies, stack dependencies go first\n   */\n  public static PRIORITIES: Record<WorkNode['type'], number> = {\n    'asset-build': 10,\n    'asset-publish': 0,\n    'stack': 5,\n  };\n  private readonly graph: WorkGraph;\n  private readonly ioHelper: IoHelper;\n\n  constructor(\n    ioHelper: IoHelper,\n    private readonly prebuildAssets: boolean,\n    private readonly idPrefix = '',\n  ) {\n    this.graph = new WorkGraph({}, ioHelper);\n    this.ioHelper = ioHelper;\n  }\n\n  private addStack(artifact: cxapi.CloudFormationStackArtifact) {\n    this.graph.addNodes({\n      type: 'stack',\n      id: `${this.idPrefix}${artifact.id}`,\n      dependencies: new Set(this.stackArtifactIds(onlyStacks(artifact.dependencies))),\n      stack: artifact,\n      deploymentState: DeploymentState.PENDING,\n      priority: WorkGraphBuilder.PRIORITIES.stack,\n    });\n  }\n\n  /**\n   * Oof, see this parameter list\n   */\n  // eslint-disable-next-line @stylistic/max-len\n  private addAsset(parentStack: cxapi.CloudFormationStackArtifact, assetManifestArtifact: cxapi.AssetManifestArtifact, assetManifest: AssetManifest, asset: IManifestEntry) {\n    // Just the artifact identifier\n    const assetId = asset.id.assetId;\n\n    const buildId = `build-${assetId}-${contentHashAny([assetId, asset.genericSource]).substring(0, 10)}`;\n    const publishId = `publish-${assetId}-${contentHashAny([assetId, asset.genericDestination]).substring(0, 10)}`;\n\n    // Build node only gets added once because they are all the same\n    if (!this.graph.tryGetNode(buildId)) {\n      const node: AssetBuildNode = {\n        type: 'asset-build',\n        id: buildId,\n        note: asset.displayName(false),\n        dependencies: new Set([\n          ...this.stackArtifactIds(assetManifestArtifact.dependencies),\n          // If we disable prebuild, then assets inherit (stack) dependencies from their parent stack\n          ...!this.prebuildAssets ? this.stackArtifactIds(onlyStacks(parentStack.dependencies)) : [],\n        ]),\n        parentStack: parentStack,\n        assetManifestArtifact,\n        assetManifest,\n        asset,\n        deploymentState: DeploymentState.PENDING,\n        priority: WorkGraphBuilder.PRIORITIES['asset-build'],\n      };\n      this.graph.addNodes(node);\n    }\n\n    const publishNode = this.graph.tryGetNode(publishId);\n    if (!publishNode) {\n      this.graph.addNodes({\n        type: 'asset-publish',\n        id: publishId,\n        note: asset.displayName(true),\n        dependencies: new Set([\n          buildId,\n        ]),\n        parentStack,\n        assetManifestArtifact,\n        assetManifest,\n        asset,\n        deploymentState: DeploymentState.PENDING,\n        priority: WorkGraphBuilder.PRIORITIES['asset-publish'],\n      });\n    }\n\n    for (const inheritedDep of this.stackArtifactIds(onlyStacks(parentStack.dependencies))) {\n      // The asset publish step also depends on the stacks that the parent depends on.\n      // This is purely cosmetic: if we don't do this, the progress printing of asset publishing\n      // is going to interfere with the progress bar of the stack deployment. We could remove this\n      // for overall faster deployments if we ever have a better method of progress displaying.\n      // Note: this may introduce a cycle if one of the parent's dependencies is another stack that\n      // depends on this asset. To workaround this we remove these cycles once all nodes have\n      // been added to the graph.\n      this.graph.addDependency(publishId, inheritedDep);\n    }\n\n    // This will work whether the stack node has been added yet or not\n    this.graph.addDependency(`${this.idPrefix}${parentStack.id}`, publishId);\n  }\n\n  public build(artifacts: cxapi.CloudArtifact[]): WorkGraph {\n    const parentStacks = stacksFromAssets(artifacts);\n\n    for (const artifact of artifacts) {\n      if (cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(artifact)) {\n        this.addStack(artifact);\n      } else if (cxapi.AssetManifestArtifact.isAssetManifestArtifact(artifact)) {\n        const manifest = AssetManifest.fromFile(artifact.file);\n\n        for (const entry of manifest.entries) {\n          const parentStack = parentStacks.get(artifact);\n          if (parentStack === undefined) {\n            throw new ToolkitError('OrphanedAssetManifest', 'Found an asset manifest that is not associated with a stack');\n          }\n          this.addAsset(parentStack, artifact, manifest, entry);\n        }\n      } else if (cxapi.NestedCloudAssemblyArtifact.isNestedCloudAssemblyArtifact(artifact)) {\n        const assembly = new cxapi.CloudAssembly(artifact.fullPath, { topoSort: false });\n        const nestedGraph = new WorkGraphBuilder(\n          this.ioHelper,\n          this.prebuildAssets,\n          `${this.idPrefix}${artifact.id}.`,\n        ).build(assembly.artifacts);\n        this.graph.absorb(nestedGraph);\n      } else {\n        // Ignore whatever else\n      }\n    }\n\n    this.graph.removeUnavailableDependencies();\n\n    // Remove any potentially introduced cycles between asset publishing and the stacks that depend on them.\n    this.removeStackPublishCycles();\n\n    return this.graph;\n  }\n\n  private stackArtifactIds(deps: cxapi.CloudArtifact[]): string[] {\n    return deps.flatMap((d) => cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(d) ? [this.stackArtifactId(d)] : []);\n  }\n\n  private stackArtifactId(artifact: cxapi.CloudArtifact): string {\n    if (!cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(artifact)) {\n      throw new ToolkitError('InvalidArtifactType', `Can only call this on CloudFormationStackArtifact, got: ${artifact.constructor.name}`);\n    }\n    return `${this.idPrefix}${artifact.id}`;\n  }\n\n  /**\n   * We may have accidentally introduced cycles in an attempt to make the messages printed to the\n   * console not interfere with each other too much. Remove them again.\n   */\n  private removeStackPublishCycles() {\n    const publishSteps = this.graph.nodesOfType('asset-publish');\n    for (const publishStep of publishSteps) {\n      for (const dep of publishStep.dependencies) {\n        if (this.graph.reachable(dep, publishStep.id)) {\n          publishStep.dependencies.delete(dep);\n        }\n      }\n    }\n  }\n}\n\nfunction stacksFromAssets(artifacts: cxapi.CloudArtifact[]) {\n  const ret = new Map<cxapi.AssetManifestArtifact, cxapi.CloudFormationStackArtifact>();\n  for (const stack of artifacts.filter(x => cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(x))) {\n    const assetArtifacts = stack.dependencies.filter((x) => cxapi.AssetManifestArtifact.isAssetManifestArtifact(x));\n    for (const art of assetArtifacts) {\n      ret.set(art, stack);\n    }\n  }\n\n  return ret;\n}\n\nfunction onlyStacks(artifacts: cxapi.CloudArtifact[]) {\n  return artifacts.filter(x => cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(x));\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"work-graph-builder.js","sourceRoot":"","sources":["work-graph-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import { AssetManifest, type IManifestEntry } from '@aws-cdk/cdk-assets-lib';\nimport * as cxapi from '@aws-cdk/cloud-assembly-api';\nimport { WorkGraph } from './work-graph';\nimport type { AssetBuildNode, MarkerNode, WorkNode } from './work-graph-types';\nimport { DeploymentState } from './work-graph-types';\nimport { ToolkitError } from '../../toolkit/toolkit-error';\nimport { contentHashAny } from '../../util';\nimport type { IoHelper } from '../io/private';\n\nexport class WorkGraphBuilder {\n  /**\n   * Default priorities for nodes\n   *\n   * Messages have the highest priority to ensure they are emitted as soon as\n   * possible (because they will be used for measuring timings).\n   *\n   * Assets builds have higher priority than the other two operations, to make good on our promise that\n   * '--prebuild-assets' will actually do assets before stacks (if it can). Unfortunately it is the\n   * default :(\n   *\n   * But between stack dependencies and publish dependencies, stack dependencies go first\n   */\n  public static PRIORITIES: Record<WorkNode['type'], number> = {\n    'asset-build': 10,\n    'asset-publish': 0,\n    'stack': 5,\n    'marker': 100,\n  };\n  private readonly graph: WorkGraph;\n  private readonly ioHelper: IoHelper;\n\n  constructor(\n    ioHelper: IoHelper,\n    private readonly prebuildAssets: boolean,\n    private readonly idPrefix = '',\n  ) {\n    this.graph = new WorkGraph({}, ioHelper);\n    this.ioHelper = ioHelper;\n  }\n\n  private addStack(artifact: cxapi.CloudFormationStackArtifact) {\n    this.graph.addNodes({\n      type: 'stack',\n      id: `${this.idPrefix}${artifact.id}`,\n      dependencies: new Set(this.stackArtifactIds(onlyStacks(artifact.dependencies))),\n      stack: artifact,\n      deploymentState: DeploymentState.PENDING,\n      priority: WorkGraphBuilder.PRIORITIES.stack,\n    });\n  }\n\n  /**\n   * Oof, see this parameter list\n   */\n  // eslint-disable-next-line @stylistic/max-len\n  private addAsset(parentStack: cxapi.CloudFormationStackArtifact, assetManifestArtifact: cxapi.AssetManifestArtifact, assetManifest: AssetManifest, asset: IManifestEntry) {\n    // Just the artifact identifier\n    const assetId = asset.id.assetId;\n\n    // Build node, contains hash of source (build only once)\n    const sourceHash = contentHashAny([assetId, asset.genericSource]).substring(0, 10);\n    const buildId = `build-${assetId}-${sourceHash}`;\n    // Publish node, contains hash of both source and dest\n    const publishId = `publish-${assetId}-${sourceHash}${contentHashAny([assetId, asset.genericDestination]).substring(0, 10)}`;\n\n    // Message to emit when we start on an asset\n    const startId = `start-${assetId}`;\n    if (!this.graph.tryGetNode(startId)) {\n      this.graph.addNodes({\n        type: 'marker',\n        id: startId,\n        dependencies: new Set(),\n        deploymentState: DeploymentState.PENDING,\n        priority: WorkGraphBuilder.PRIORITIES.marker,\n        marker: { type: 'start-asset', asset },\n      } satisfies MarkerNode);\n    }\n\n    // Message to emit when we end an asset\n    const endId = `end-${assetId}`;\n    if (!this.graph.tryGetNode(endId)) {\n      this.graph.addNodes({\n        type: 'marker',\n        id: endId,\n        dependencies: new Set(),\n        deploymentState: DeploymentState.PENDING,\n        priority: WorkGraphBuilder.PRIORITIES.marker,\n        marker: { type: 'end-asset', asset },\n      } satisfies MarkerNode);\n    }\n\n    // Build node only gets added once because they are all the same\n    if (!this.graph.tryGetNode(buildId)) {\n      const node: AssetBuildNode = {\n        type: 'asset-build',\n        id: buildId,\n        note: asset.displayName(false),\n        dependencies: new Set([\n          // Build depends on the start message having been emitted.\n          startId,\n          ...this.stackArtifactIds(assetManifestArtifact.dependencies),\n          // If we disable prebuild, then assets inherit (stack) dependencies from their parent stack\n          ...!this.prebuildAssets ? this.stackArtifactIds(onlyStacks(parentStack.dependencies)) : [],\n        ]),\n        parentStack: parentStack,\n        assetManifestArtifact,\n        assetManifest,\n        asset,\n        deploymentState: DeploymentState.PENDING,\n        priority: WorkGraphBuilder.PRIORITIES['asset-build'],\n      };\n      this.graph.addNodes(node);\n    }\n\n    const publishNode = this.graph.tryGetNode(publishId);\n    if (!publishNode) {\n      this.graph.addNodes({\n        type: 'asset-publish',\n        id: publishId,\n        note: asset.displayName(true),\n        dependencies: new Set([\n          buildId,\n        ]),\n        parentStack,\n        assetManifestArtifact,\n        assetManifest,\n        asset,\n        deploymentState: DeploymentState.PENDING,\n        priority: WorkGraphBuilder.PRIORITIES['asset-publish'],\n      });\n\n      // Every publish node that we add must complete before we fire the \"done with publishing this asset\" message.\n      this.graph.addDependency(endId, publishId);\n    }\n\n    for (const inheritedDep of this.stackArtifactIds(onlyStacks(parentStack.dependencies))) {\n      // The asset publish step also depends on the stacks that the parent depends on.\n      // This is purely cosmetic: if we don't do this, the progress printing of asset publishing\n      // is going to interfere with the progress bar of the stack deployment. We could remove this\n      // for overall faster deployments if we ever have a better method of progress displaying.\n      // Note: this may introduce a cycle if one of the parent's dependencies is another stack that\n      // depends on this asset. To workaround this we remove these cycles once all nodes have\n      // been added to the graph.\n      this.graph.addDependency(publishId, inheritedDep);\n    }\n\n    // This will work whether the stack node has been added yet or not\n    this.graph.addDependency(`${this.idPrefix}${parentStack.id}`, publishId);\n  }\n\n  public build(artifacts: cxapi.CloudArtifact[]): WorkGraph {\n    const parentStacks = stacksFromAssets(artifacts);\n\n    for (const artifact of artifacts) {\n      if (cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(artifact)) {\n        this.addStack(artifact);\n      } else if (cxapi.AssetManifestArtifact.isAssetManifestArtifact(artifact)) {\n        const manifest = AssetManifest.fromFile(artifact.file);\n\n        for (const entry of manifest.entries) {\n          const parentStack = parentStacks.get(artifact);\n          if (parentStack === undefined) {\n            throw new ToolkitError('OrphanedAssetManifest', 'Found an asset manifest that is not associated with a stack');\n          }\n          this.addAsset(parentStack, artifact, manifest, entry);\n        }\n      } else if (cxapi.NestedCloudAssemblyArtifact.isNestedCloudAssemblyArtifact(artifact)) {\n        const assembly = new cxapi.CloudAssembly(artifact.fullPath, { topoSort: false });\n        const nestedGraph = new WorkGraphBuilder(\n          this.ioHelper,\n          this.prebuildAssets,\n          `${this.idPrefix}${artifact.id}.`,\n        ).build(assembly.artifacts);\n        this.graph.absorb(nestedGraph);\n      } else {\n        // Ignore whatever else\n      }\n    }\n\n    this.graph.removeUnavailableDependencies();\n\n    // Remove any potentially introduced cycles between asset publishing and the stacks that depend on them.\n    this.removeStackPublishCycles();\n\n    return this.graph;\n  }\n\n  private stackArtifactIds(deps: cxapi.CloudArtifact[]): string[] {\n    return deps.flatMap((d) => cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(d) ? [this.stackArtifactId(d)] : []);\n  }\n\n  private stackArtifactId(artifact: cxapi.CloudArtifact): string {\n    if (!cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(artifact)) {\n      throw new ToolkitError('InvalidArtifactType', `Can only call this on CloudFormationStackArtifact, got: ${artifact.constructor.name}`);\n    }\n    return `${this.idPrefix}${artifact.id}`;\n  }\n\n  /**\n   * We may have accidentally introduced cycles in an attempt to make the messages printed to the\n   * console not interfere with each other too much. Remove them again.\n   */\n  private removeStackPublishCycles() {\n    const publishSteps = this.graph.nodesOfType('asset-publish');\n    for (const publishStep of publishSteps) {\n      for (const dep of publishStep.dependencies) {\n        if (this.graph.reachable(dep, publishStep.id)) {\n          publishStep.dependencies.delete(dep);\n        }\n      }\n    }\n  }\n}\n\nfunction stacksFromAssets(artifacts: cxapi.CloudArtifact[]) {\n  const ret = new Map<cxapi.AssetManifestArtifact, cxapi.CloudFormationStackArtifact>();\n  for (const stack of artifacts.filter(x => cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(x))) {\n    const assetArtifacts = stack.dependencies.filter((x) => cxapi.AssetManifestArtifact.isAssetManifestArtifact(x));\n    for (const art of assetArtifacts) {\n      ret.set(art, stack);\n    }\n  }\n\n  return ret;\n}\n\nfunction onlyStacks(artifacts: cxapi.CloudArtifact[]) {\n  return artifacts.filter(x => cxapi.CloudFormationStackArtifact.isCloudFormationStackArtifact(x));\n}\n\n"]}

package/lib/api/work-graph/work-graph-types.d.ts

@@ -8,19 +8,19 @@ export declare enum DeploymentState {
     FAILED = "failed",
     SKIPPED = "skipped"
 }
-export type WorkNode = StackNode | AssetBuildNode | AssetPublishNode;
+export type WorkNode = StackNode | AssetBuildNode | AssetPublishNode | MarkerNode;
 export interface WorkNodeCommon {
     readonly id: string;
     readonly dependencies: Set<string>;
     deploymentState: DeploymentState;
     /** Some readable information to attach to the id, which may be unreadable */
     readonly note?: string;
+    /** Sort by priority when picking up work, higher is earlier */
+    readonly priority?: number;
 }
 export interface StackNode extends WorkNodeCommon {
     readonly type: 'stack';
     readonly stack: cxapi.CloudFormationStackArtifact;
-    /** Sort by priority when picking up work, higher is earlier */
-    readonly priority?: number;
 }
 export interface AssetBuildNode extends WorkNodeCommon {
     readonly type: 'asset-build';
@@ -32,8 +32,6 @@ export interface AssetBuildNode extends WorkNodeCommon {
     readonly parentStack: cxapi.CloudFormationStackArtifact;
     /** The asset that needs to be built */
     readonly asset: IManifestEntry;
-    /** Sort by priority when picking up work, higher is earlier */
-    readonly priority?: number;
 }
 export interface AssetPublishNode extends WorkNodeCommon {
     readonly type: 'asset-publish';
@@ -45,7 +43,21 @@ export interface AssetPublishNode extends WorkNodeCommon {
     readonly parentStack: cxapi.CloudFormationStackArtifact;
     /** The asset that needs to be published */
     readonly asset: IManifestEntry;
-    /** Sort by priority when picking up work, higher is earlier */
-    readonly priority?: number;
+}
+/**
+ * A node that represents a message to the IoHost to be emitted at a certain point in the graph execution.
+ *
+ * These are used to bookend certain parts of the graph.
+ */
+export interface MarkerNode extends WorkNodeCommon {
+    readonly type: 'marker';
+    /** The event to emit when this node is reached. */
+    readonly marker: {
+        type: 'start-asset';
+        asset: IManifestEntry;
+    } | {
+        type: 'end-asset';
+        asset: IManifestEntry;
+    };
 }
 //# sourceMappingURL=work-graph-types.d.ts.map

package/lib/api/work-graph/work-graph-types.js

@@ -10,4 +10,4 @@ var DeploymentState;
     DeploymentState["FAILED"] = "failed";
     DeploymentState["SKIPPED"] = "skipped";
 })(DeploymentState || (exports.DeploymentState = DeploymentState = {}));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/work-graph/work-graph.d.ts

@@ -1,4 +1,4 @@
-import type { WorkNode, StackNode, AssetBuildNode, AssetPublishNode } from './work-graph-types';
+import type { WorkNode, StackNode, AssetBuildNode, AssetPublishNode, MarkerNode } from './work-graph-types';
 import type { IoHelper } from '../io/private';
 export type Concurrency = number | Record<WorkNode['type'], number>;
 export declare class WorkGraph {
@@ -80,5 +80,6 @@ export interface WorkGraphActions {
     deployStack: (stackNode: StackNode) => Promise<void>;
     buildAsset: (assetNode: AssetBuildNode) => Promise<void>;
     publishAsset: (assetNode: AssetPublishNode) => Promise<void>;
+    marker: (markerNode: MarkerNode) => Promise<void>;
 }
 //# sourceMappingURL=work-graph.d.ts.map