@lambda-kata/cdk 0.1.3-rc.3 → 0.1.3-rc.4

package/out/tsc/src/aws-layer-manager.d.ts

@@ -0,0 +1,465 @@
+/**
+ * AWS Lambda Layer Manager with SDK v3 Integration
+ *
+ * This module provides AWS Lambda Layer management functionality using AWS SDK v3.
+ * It handles layer creation, searching, and compatibility validation for Node.js
+ * runtime layers used by Lambda Kata.
+ *
+ * Key features:
+ * - AWS SDK v3 Lambda client integration with configurable options
+ * - Automatic pagination handling for layer listing operations
+ * - Layer compatibility validation based on Node.js version and architecture
+ * - Comprehensive error handling with retry logic
+ * - Idempotent operations to prevent duplicate layer creation
+ *
+ * @module aws-layer-manager
+ */
+import { LambdaClientConfig } from '@aws-sdk/client-lambda';
+import { LayerManager, LayerInfo, LayerSearchOptions, LayerRequirements, LayerCreationOptions, Logger } from './nodejs-layer-manager';
+/**
+ * Configuration options for AWSLayerManager.
+ */
+export interface AWSLayerManagerOptions {
+    /**
+     * AWS SDK configuration for Lambda client.
+     * If not provided, uses default AWS SDK configuration.
+     */
+    awsSdkConfig?: LambdaClientConfig;
+    /**
+     * Logger for debugging and monitoring.
+     * If not provided, uses createDefaultLogger().
+     */
+    logger?: Logger;
+    /**
+     * Maximum age in milliseconds for layers to be considered fresh.
+     * Layers older than this may be recreated.
+     * Default: 7 days (604800000ms)
+     */
+    maxLayerAge?: number;
+    /**
+     * Maximum number of retries for AWS API operations.
+     * Default: 3
+     */
+    maxRetries?: number;
+    /**
+     * Base delay in milliseconds for exponential backoff.
+     * Default: 1000ms (1 second)
+     */
+    retryBaseDelay?: number;
+    /**
+     * Circuit breaker failure threshold.
+     * Number of consecutive failures before opening the circuit.
+     * Default: 5
+     */
+    circuitBreakerFailureThreshold?: number;
+    /**
+     * Circuit breaker timeout in milliseconds.
+     * How long to wait before transitioning from OPEN to HALF_OPEN.
+     * Default: 60000ms (1 minute)
+     */
+    circuitBreakerTimeout?: number;
+    /**
+     * Circuit breaker success threshold for HALF_OPEN state.
+     * Number of consecutive successes needed to close the circuit.
+     * Default: 2
+     */
+    circuitBreakerSuccessThreshold?: number;
+}
+/**
+ * AWS Lambda Layer Manager implementation using AWS SDK v3.
+ *
+ * Provides comprehensive layer management functionality including:
+ * - Layer searching with pagination support
+ * - Layer compatibility validation
+ * - Layer creation with proper metadata
+ * - Error handling with exponential backoff retry logic
+ * - Circuit breaker pattern for AWS API resilience
+ * - Concurrent operation coordination to prevent duplicate layer creation
+ *
+ * @example
+ * ```typescript
+ * const manager = new AWSLayerManager({
+ *   awsSdkConfig: { region: 'us-east-1' },
+ *   logger: new ConsoleLogger()
+ * });
+ *
+ * const layer = await manager.findExistingLayer({
+ *   layerName: 'lambda-kata-nodejs-nodejs20.x-x86_64',
+ *   requirements: {
+ *     nodeVersion: '20.10.0',
+ *     architecture: 'x86_64'
+ *   }
+ * });
+ * ```
+                */
+export declare class AWSLayerManager implements LayerManager {
+    private readonly lambdaClient;
+    private readonly logger;
+    private readonly maxLayerAge;
+    private readonly maxRetries;
+    private readonly retryBaseDelay;
+    private readonly circuitBreaker;
+    /**
+     * Map of layer names to in-progress creation operations.
+     * Used to coordinate concurrent calls and prevent duplicate layer creation.
+     */
+    private readonly layerCreationLocks;
+    /**
+     * AWS Lambda Layer size limits (in bytes).
+     * These are AWS service limits that cannot be exceeded.
+     */
+    private static readonly MAX_LAYER_SIZE_UNZIPPED;
+    private static readonly MAX_LAYER_SIZE_ZIPPED;
+    /**
+     * Docker operation timeout in milliseconds.
+     */
+    private static readonly DOCKER_TIMEOUT;
+    constructor(options?: AWSLayerManagerOptions);
+    /**
+     * Searches for an existing compatible Node.js layer.
+     *
+     * Uses AWS SDK v3 pagination to efficiently search through all layers
+     * in the account and region. Validates compatibility based on layer
+     * metadata and requirements.
+     *
+     * @param options - Search criteria and requirements
+     * @returns Promise resolving to layer info if found, null otherwise
+     * @throws NodeRuntimeLayerError if search fails
+     */
+    findExistingLayer(options: LayerSearchOptions): Promise<LayerInfo | null>;
+    /**
+     * Creates a new Node.js Lambda Layer with concurrent operation coordination.
+     *
+     * This method extracts the Node.js binary from the corresponding AWS Lambda
+     * Docker image, packages it in the proper Lambda Layer directory structure,
+     * and publishes it to AWS Lambda with appropriate metadata.
+     *
+     * Enhanced with concurrent operation coordination to prevent duplicate layer
+     * creation when multiple calls are made with identical parameters. If a layer
+     * creation is already in progress for the same layer name, subsequent calls
+     * will wait for the existing operation to complete rather than starting a
+     * duplicate operation.
+     *
+     * Process:
+     * 1. Check for existing in-progress layer creation operation
+     * 2. If operation exists, wait for its completion
+     * 3. If no operation exists, start new layer creation with lock
+     * 4. Create temporary directory for layer contents
+     * 5. Extract Node.js binary from Docker container
+     * 6. Create proper Lambda Layer directory structure (/opt/nodejs/bin/)
+     * 7. Create ZIP archive with correct permissions
+     * 8. Validate size limits
+     * 9. Publish to AWS Lambda
+     * 10. Clean up temporary files and release lock
+     *
+     * Enhanced with comprehensive resource cleanup on failure to prevent orphaned resources.
+     *
+     * @param options - Layer creation configuration
+     * @returns Promise resolving to information about the created layer
+     * @throws NodeRuntimeLayerError if creation fails
+     */
+    createNodeLayer(options: LayerCreationOptions): Promise<LayerInfo>;
+    /**
+     * Performs the actual layer creation operation without concurrent coordination.
+     *
+     * This is the core layer creation logic extracted from the original createNodeLayer
+     * method to separate concerns between concurrent coordination and actual creation.
+     *
+     * @param options - Layer creation configuration
+     * @returns Promise resolving to information about the created layer
+     * @throws NodeRuntimeLayerError if creation fails
+     */
+    private performLayerCreation;
+    /**
+     * Validates whether a layer meets the specified requirements.
+     *
+     * Checks layer compatibility based on:
+     * - Node.js version exact match
+     * - Architecture compatibility
+     * - Layer age (if maxAge is specified in requirements)
+     *
+     * @param layer - The layer to validate
+     * @param requirements - The requirements to check against
+     * @returns true if the layer is compatible, false otherwise
+     */
+    validateLayerCompatibility(layer: LayerInfo, requirements: LayerRequirements): boolean;
+    /**
+     * Lists layers by name using AWS SDK v3 pagination with retry logic.
+     *
+     * Efficiently searches through all layers in the account and region
+     * to find layers matching the specified name pattern. Uses retry logic
+     * to handle transient pagination failures.
+     *
+     * @param layerName - The layer name to search for
+     * @returns Promise resolving to array of matching layers
+     * @throws Error if AWS API operations fail
+     */
+    private listLayersByName;
+    /**
+     * Gets detailed information about a specific layer version.
+     *
+     * Retrieves layer metadata and extracts Node.js version and architecture
+     * information from the layer description or other metadata.
+     *
+     * @param layerName - The name of the layer
+     * @param version - The version number of the layer
+     * @returns Promise resolving to LayerInfo
+     * @throws Error if layer information cannot be retrieved
+     */
+    private getLayerInfo;
+    /**
+     * Parses layer metadata to extract Node.js version and architecture.
+     *
+     * Attempts to extract information from layer description or falls back
+     * to parsing the layer name if description doesn't contain the required data.
+     *
+     * @param description - The layer description
+     * @param layerName - The layer name as fallback
+     * @returns Object containing nodeVersion and architecture
+     */
+    private parseLayerMetadata;
+    /**
+     * Executes an AWS API operation with exponential backoff retry logic and circuit breaker protection.
+     *
+     * Implements retry logic for transient AWS API failures with exponential
+     * backoff and jitter to avoid thundering herd problems. Uses circuit breaker
+     * pattern to prevent cascading failures during AWS service outages.
+     *
+     * @param operation - The async operation to execute
+     * @returns Promise resolving to the operation result
+     * @throws Error if all retries are exhausted or circuit breaker is open
+     */
+    private executeWithRetry;
+    /**
+     * Determines if an error is retryable.
+     *
+     * @param error - The error to check
+     * @returns true if the error is retryable, false otherwise
+     */
+    private isRetryableError;
+    /**
+     * Checks if an error is a network-related error that should be retried.
+     *
+     * @param error - The error to check
+     * @returns true if it's a retryable network error
+     */
+    private isNetworkError;
+    /**
+     * Calculates retry delay with exponential backoff and jitter.
+     *
+     * @param attempt - The current attempt number (0-based)
+     * @returns Delay in milliseconds
+     */
+    private calculateRetryDelay;
+    /**
+     * Sleeps for the specified number of milliseconds.
+     *
+     * @param ms - Milliseconds to sleep
+     * @returns Promise that resolves after the delay
+     */
+    private sleep;
+    /**
+     * Gets the current circuit breaker state for monitoring and debugging.
+     *
+     * @returns Object containing circuit breaker state information
+     */
+    getCircuitBreakerState(): {
+        state: string;
+        failureCount: number;
+        successCount: number;
+    };
+    /**
+     * Gets the current concurrent operation state for monitoring and debugging.
+     *
+     * @returns Object containing information about in-progress layer creation operations
+     */
+    getConcurrentOperationState(): {
+        activeOperations: number;
+        operations: Array<{
+            layerName: string;
+            startTime: number;
+            duration: number;
+            waiters: number;
+            nodeVersion: string;
+            architecture: string;
+        }>;
+    };
+    /**
+     * Destroys the AWS Lambda client and cleans up resources.
+     *
+     * Should be called when the manager is no longer needed to prevent
+     * resource leaks. Also cleans up any remaining concurrent operation locks.
+     */
+    destroy(): void;
+    /**
+     * Creates a temporary directory for layer creation operations.
+     *
+     * @returns Promise resolving to the temporary directory path
+     * @throws Error if directory creation fails
+     */
+    private createTempDirectory;
+    /**
+     * Extracts Node.js binary from AWS Lambda Docker container with resource tracking.
+     *
+     * Enhanced version that tracks Docker containers for cleanup on failure.
+     * Uses Docker to run the AWS Lambda runtime image and copy the Node.js
+     * binary to the local filesystem for packaging in the layer.
+     *
+     * @param nodeVersion - The Node.js version (e.g., "20.10.0")
+     * @param architecture - The target architecture
+     * @param tempDir - Temporary directory for extraction
+     * @param resourceTracker - Resource tracker for cleanup
+     * @returns Promise resolving to the path of the extracted binary
+     * @throws NodeRuntimeLayerError if extraction fails
+     */
+    private extractNodeBinaryFromDockerWithTracking;
+    /**
+     * Creates the proper Lambda Layer directory structure.
+     *
+     * Lambda Layers must follow a specific directory structure:
+     * - /opt/nodejs/bin/ for Node.js binaries
+     *
+     * @param tempDir - Base temporary directory
+     * @param nodeBinaryPath - Path to the Node.js binary
+     * @returns Promise resolving to the layer directory path
+     * @throws Error if directory creation fails
+     */
+    private createLayerDirectoryStructure;
+    /**
+     * Creates a ZIP archive of the layer contents with compression optimization.
+     *
+     * Uses Python's zipfile module to create a properly compressed ZIP file with
+     * file permissions preserved for the Node.js binary. Implements compression
+     * optimization to minimize storage and transfer costs.
+     *
+     * @param layerDir - Directory containing the layer contents
+     * @param layerName - Name of the layer (used for ZIP filename)
+     * @returns Promise resolving to the ZIP file path
+     * @throws Error if ZIP creation fails
+     */
+    private createLayerZipArchive;
+    /**
+     * Calculates the total size of all files in a directory.
+     *
+     * @param dirPath - Directory path to analyze
+     * @returns Promise resolving to total size in bytes
+     */
+    private calculateDirectorySize;
+    /**
+     * Fallback ZIP creation using system zip command.
+     *
+     * @param layerDir - Directory containing the layer contents
+     * @param zipFilePath - Target ZIP file path
+     * @returns Promise resolving to the ZIP file path
+     * @throws Error if ZIP creation fails
+     */
+    private createZipFallback;
+    /**
+     * Validates that the layer ZIP file meets AWS size limits.
+     *
+     * AWS Lambda has strict size limits for layers:
+     * - 50MB for zipped layer
+     * - 250MB for unzipped layer
+     *
+     * Enhanced to check both zipped and unzipped sizes with comprehensive
+     * error reporting and optimization suggestions.
+     *
+     * @param zipFilePath - Path to the ZIP file
+     * @throws NodeRuntimeLayerError if size limits are exceeded
+     */
+    private preValidateLayerContent;
+    /**
+     * Validates layer size limits after ZIP creation.
+     *
+     * @param zipFilePath - Path to the ZIP file
+     * @throws NodeRuntimeLayerError if size limits are exceeded
+     */
+    private validateLayerSize;
+    /**
+     * Calculates the unzipped size of a ZIP file by examining its contents.
+     *
+     * Uses Python's zipfile module to read ZIP metadata and calculate
+     * the total uncompressed size without extracting files.
+     *
+     * @param zipFilePath - Path to the ZIP file
+     * @returns Promise resolving to unzipped size in bytes
+     * @throws Error if size calculation fails
+     */
+    private calculateUnzippedSize;
+    /**
+     * Publishes the layer to AWS Lambda.
+     *
+     * Uses the AWS SDK v3 Lambda client to publish the layer with proper
+     * metadata including compatible runtimes and architectures.
+     *
+     * @param options - Layer creation options
+     * @param zipFilePath - Path to the ZIP file
+     * @returns Promise resolving to LayerInfo
+     * @throws NodeRuntimeLayerError if publishing fails
+     */
+    private publishLayerToAWS;
+    /**
+     * Executes a Docker command with timeout and error handling.
+     *
+     * @param args - Docker command arguments
+     * @returns Promise that resolves when command completes successfully
+     * @throws Error if command fails
+     */
+    private executeDockerCommand;
+    /**
+     * Executes a system command with timeout and error handling, capturing output.
+     *
+     * @param command - Command to execute
+     * @param args - Command arguments
+     * @param options - Execution options including working directory
+     * @returns Promise resolving to command output (stdout and stderr)
+     * @throws Error if command fails
+     */
+    private executeCommandWithOutput;
+    /**
+     * Executes a system command with timeout and error handling.
+     *
+     * @param command - Command to execute
+     * @param args - Command arguments
+     * @param options - Execution options including working directory
+     * @returns Promise that resolves when command completes successfully
+     * @throws Error if command fails
+     */
+    private executeCommand;
+    /**
+     * Legacy cleanup method for backward compatibility.
+     *
+     * @deprecated Use performComprehensiveCleanup with ResourceTracker instead
+     * @param tempDir - Temporary directory to remove (if exists)
+     * @param zipFilePath - ZIP file to remove (if exists)
+     */
+    private cleanupTempResources;
+    /**
+     * Legacy Docker extraction method for backward compatibility.
+     *
+     * @deprecated Use extractNodeBinaryFromDockerWithTracking instead
+     */
+    private extractNodeBinaryFromDocker;
+    /**
+     * Creates an enhanced error with cleanup context preservation.
+     *
+     * Preserves the original error while adding context about the layer creation
+     * operation that failed. This maintains debugging capability while providing
+     * additional context for troubleshooting.
+     *
+     * @param originalError - The original error that occurred
+     * @param options - Layer creation options for context
+     * @returns Enhanced NodeRuntimeLayerError with preserved context
+     */
+    private createEnhancedError;
+    /**
+     * Performs comprehensive cleanup of all tracked resources.
+     *
+     * Cleans up Docker containers, temporary directories, and ZIP files.
+     * Cleanup failures are logged as warnings but do not prevent the cleanup
+     * of other resources or mask the original error.
+     *
+     * @param resourceTracker - Tracker containing all resources to clean up
+     */
+    private performComprehensiveCleanup;
+}

package/out/tsc/src/docker-runtime-detector.d.ts

@@ -0,0 +1,168 @@
+import { RuntimeDetector, NodeVersionInfo, Logger } from './nodejs-layer-manager';
+/**
+ * Configuration options for DockerRuntimeDetector.
+ */
+export interface DockerRuntimeDetectorOptions {
+    /**
+     * Cache TTL in milliseconds. Default: 1 hour (3600000ms)
+     */
+    cacheTtl?: number;
+    /**
+     * Docker command timeout in milliseconds. Default: 60 seconds (60000ms)
+     */
+    dockerTimeout?: number;
+    /**
+     * Logger for debugging and monitoring. Default: createDefaultLogger()
+     */
+    logger?: Logger;
+    /**
+     * Whether to enable fallback to known version mappings when Docker fails.
+     * Default: true
+     */
+    enableFallback?: boolean;
+}
+/**
+ * Docker-based implementation of RuntimeDetector.
+ *
+ * Uses official AWS Lambda runtime Docker images to detect exact Node.js versions.
+ * Implements caching to avoid repeated Docker operations and provides fallback
+ * version mappings when Docker is unavailable.
+ *
+ * @example
+ * ```typescript
+ * const detector = new DockerRuntimeDetector();
+ * const versionInfo = await detector.detectNodeVersion('nodejs20.x', 'x86_64');
+ * console.log(`Node.js version: ${versionInfo.version}`);
+ * ```
+ */
+export declare class DockerRuntimeDetector implements RuntimeDetector {
+    private readonly versionCache;
+    private readonly cacheTtl;
+    private readonly dockerTimeout;
+    private readonly logger;
+    private readonly enableFallback;
+    /**
+     * Known fallback version mappings for when Docker is unavailable.
+     * These are based on AWS Lambda runtime documentation and should be
+     * updated when AWS releases new runtime versions.
+     */
+    private static readonly FALLBACK_VERSIONS;
+    /**
+     * Supported AWS Lambda Node.js runtimes.
+     */
+    private static readonly SUPPORTED_RUNTIMES;
+    /**
+     * Supported architectures.
+     */
+    private static readonly SUPPORTED_ARCHITECTURES;
+    constructor(options?: DockerRuntimeDetectorOptions);
+    /**
+     * Detects the exact Node.js version for a given runtime and architecture.
+     *
+     * First checks the cache for existing version information. If not cached or expired,
+     * attempts to detect the version using Docker. Falls back to known version mappings
+     * if Docker operations fail and fallback is enabled.
+     *
+     * @param runtimeName - The AWS Lambda runtime (e.g., "nodejs20.x")
+     * @param architecture - The target architecture ("x86_64" or "arm64")
+     * @returns Promise resolving to Node.js version information
+     * @throws NodeRuntimeLayerError if detection fails
+     */
+    detectNodeVersion(runtimeName: string, architecture: string): Promise<NodeVersionInfo>;
+    /**
+     * Validates input parameters for runtime name and architecture.
+     *
+     * @param runtimeName - The runtime name to validate
+     * @param architecture - The architecture to validate
+     * @throws NodeRuntimeLayerError if inputs are invalid
+     */
+    private validateInputs;
+    /**
+     * Retrieves cached version information if available and not expired.
+     *
+     * @param cacheKey - The cache key to look up
+     * @returns Cached version entry if valid, null otherwise
+     */
+    private getCachedVersion;
+    /**
+     * Caches version information with TTL.
+     *
+     * @param cacheKey - The cache key to store under
+     * @param versionInfo - The version information to cache
+     */
+    private cacheVersion;
+    /**
+     * Detects Node.js version using Docker by pulling AWS Lambda runtime image
+     * and executing `node --version` within a container.
+     *
+     * @param runtimeName - The AWS Lambda runtime name
+     * @param architecture - The target architecture
+     * @returns Promise resolving to version information
+     * @throws NodeRuntimeLayerError if Docker operations fail
+     */
+    private detectVersionFromDocker;
+    /**
+     * Builds the Docker image name for AWS Lambda runtime.
+     *
+     * @param runtimeName - The AWS Lambda runtime name (e.g., "nodejs20.x")
+     * @param architecture - The target architecture
+     * @returns Docker image name (e.g., "public.ecr.aws/lambda/nodejs:20-x86_64")
+     */
+    private buildDockerImageName;
+    /**
+     * Checks if Docker image exists locally before pulling.
+     *
+     * @param dockerImage - The Docker image to check
+     * @returns Promise<boolean> - true if image exists locally
+     */
+    private checkDockerImageExists;
+    /**
+     * Pulls a Docker image using the docker pull command.
+     * Optimized to skip pull if image already exists locally.
+     *
+     * @param dockerImage - The Docker image to pull
+     * @returns Promise that resolves when the image is pulled
+     * @throws Error if docker pull fails
+     */
+    private pullDockerImage;
+    /**
+     * Extracts Node.js version by running `node --version` in a Docker container.
+     *
+     * @param dockerImage - The Docker image to run
+     * @returns Promise resolving to the Node.js version string
+     * @throws Error if container execution fails
+     */
+    private extractNodeVersionFromContainer;
+    /**
+     * Validates that a version string follows semantic versioning format.
+     *
+     * @param version - The version string to validate
+     * @returns true if the version is valid, false otherwise
+     */
+    private isValidSemanticVersion;
+    /**
+     * Provides fallback version information when Docker detection fails.
+     *
+     * @param runtimeName - The AWS Lambda runtime name
+     * @param architecture - The target architecture
+     * @returns NodeVersionInfo with fallback version
+     * @throws NodeRuntimeLayerError if no fallback is available
+     */
+    private getFallbackVersion;
+    /**
+     * Clears the version cache.
+     * Useful for testing or when cache invalidation is needed.
+     */
+    clearCache(): void;
+    /**
+     * Gets the current cache size.
+     * Useful for monitoring and debugging.
+     */
+    getCacheSize(): number;
+    /**
+     * Checks if Docker is available on the system.
+     *
+     * @returns Promise resolving to true if Docker is available, false otherwise
+     */
+    isDockerAvailable(): Promise<boolean>;
+}

package/out/tsc/src/ensure-node-runtime-layer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Main API function for Node.js runtime layer management
+ *
+ * This module provides the primary entry point for ensuring Node.js runtime layers
+ * exist in AWS Lambda. It coordinates between runtime detection and layer management
+ * components to provide a seamless experience for CDK integration.
+ *
+ * @module ensure-node-runtime-layer
+ */
+import { EnsureNodeRuntimeLayerOptions, EnsureNodeRuntimeLayerResult } from './nodejs-layer-manager';
+/**
+ * Ensures a Node.js runtime layer exists for the specified configuration.
+ *
+ * This is the main API function that coordinates runtime detection and layer management
+ * to ensure the correct Node.js binaries are available for Lambda Kata execution.
+ *
+ * The function performs the following operations:
+ * 1. Validates all input parameters
+ * 2. Detects the exact Node.js version for the runtime
+ * 3. Searches for existing compatible layers
+ * 4. Creates a new layer if none exists or is compatible
+ * 5. Returns comprehensive result information
+ *
+ * @param options - Configuration options for layer management
+ * @returns Promise resolving to layer information and metadata
+ * @throws NodeRuntimeLayerError for validation failures or operational errors
+ *
+ * @example
+ * ```typescript
+ * const result = await ensureNodeRuntimeLayer({
+ *   runtimeName: 'nodejs20.x',
+ *   architecture: 'x86_64',
+ *   region: 'us-east-1',
+ *   accountId: '123456789012'
+ * });
+ *
+ * console.log(`Layer ARN: ${result.layerArn}`);
+ * console.log(`Node.js version: ${result.nodeVersion}`);
+ * console.log(`Created new layer: ${result.created}`);
+ * ```
+ */
+export declare function ensureNodeRuntimeLayer(options: EnsureNodeRuntimeLayerOptions): Promise<EnsureNodeRuntimeLayerResult>;

package/out/tsc/src/index.d.ts

@@ -23,3 +23,8 @@ export { MockLicensingService, createMockLicensingService, } from './mock-licens
 export { resolveAccountId, resolveAccountIdWithSource, isValidAccountIdFormat, AccountResolutionError, AccountResolutionResult, AccountResolverOptions, } from './account-resolver';
 export { kata, kataWithAccountId, applyTransformation, handleUnlicensed, isKataTransformed, getKataPromise, KataWrapperOptions, KataResult, } from './kata-wrapper';
 export { createKataConfigLayer, generateConfigContent, KataConfigLayerProps, CONFIG_DIR_NAME, CONFIG_FILE_NAME, HANDLER_CONFIG_KEY, } from './config-layer';
+export { EnsureNodeRuntimeLayerOptions, EnsureNodeRuntimeLayerResult, NodeVersionInfo, LayerInfo, LayerSearchOptions, LayerRequirements, LayerCreationOptions, Logger, RuntimeDetector, LayerManager, ErrorCodes, NodeRuntimeLayerError, VersionCacheEntry, LayerMetadata, } from './nodejs-layer-manager';
+export { DockerRuntimeDetector, DockerRuntimeDetectorOptions, } from './docker-runtime-detector';
+export { AWSLayerManager, AWSLayerManagerOptions, } from './aws-layer-manager';
+export { NoOpLogger, ConsoleLogger, createDefaultLogger, OperationTimer, } from './logger';
+export { ensureNodeRuntimeLayer } from './ensure-node-runtime-layer';