diff --git a/.cursor/commands/code-review.md b/.cursor/commands/code-review.md
new file mode 100644
index 000000000..c336c0aa1
--- /dev/null
+++ b/.cursor/commands/code-review.md
@@ -0,0 +1,122 @@
+---
+name: code-review
+description: Automated PR review using comprehensive checklist tailored for Contentstack CLI plugins
+---
+
+# Code Review Command
+
+## Usage Patterns
+
+### Scope-Based Reviews
+- `/code-review` - Review all current changes with full checklist
+- `/code-review --scope typescript` - Focus on TypeScript configuration and patterns
+- `/code-review --scope testing` - Focus on Mocha/Chai/Sinon test patterns
+- `/code-review --scope contentstack` - Focus on API integration and CLI patterns
+- `/code-review --scope oclif` - Focus on command structure and OCLIF patterns
+
+### Severity Filtering
+- `/code-review --severity critical` - Show only critical issues (security, breaking changes)
+- `/code-review --severity high` - Show high and critical issues
+- `/code-review --severity all` - Show all issues including suggestions
+
+### Package-Aware Reviews
+- `/code-review --package contentstack-import` - Review changes in specific package
+- `/code-review --package-type plugin` - Review plugin packages only
+- `/code-review --package-type library` - Review library packages (e.g., variants)
+
+### File Type Focus
+- `/code-review --files commands` - Review command files only
+- `/code-review --files tests` - Review test files only
+- `/code-review --files modules` - Review import/export modules
+
+## Comprehensive Review Checklist
+
+### Monorepo Structure Compliance
+- **Package organization**: Proper placement in `packages/` structure
+- **pnpm workspace**: Correct `package.json` workspace configuration
+- **Build artifacts**: No `lib/` directories committed to version control
+- **Dependencies**: Proper use of shared utilities (`@contentstack/cli-command`, `@contentstack/cli-utilities`)
+
+### TypeScript Standards (Repository-Specific)
+- **Configuration compliance**: Follows package-specific TypeScript config
+- **Naming conventions**: kebab-case files, PascalCase classes, camelCase functions
+- **Type safety**: Appropriate use of strict mode vs relaxed settings per package
+- **Import patterns**: ES modules with proper default/named exports
+- **Migration strategy**: Proper use of `@ts-ignore` during gradual migration
+
+### OCLIF Command Patterns (Actual Implementation)
+- **Base class usage**: Extends `@contentstack/cli-command` (not `@oclif/core`)
+- **Command structure**: Proper `static description`, `examples`, `flags`
+- **Topic organization**: Uses `cm` topic structure (`cm:stacks:import`)
+- **Error handling**: Uses `handleAndLogError` from utilities
+- **Validation**: Early flag validation and user-friendly error messages
+- **Service delegation**: Commands orchestrate, services implement business logic
+
+### Testing Excellence (Mocha/Chai/Sinon Stack)
+- **Framework compliance**: Uses Mocha + Chai + Sinon (not Jest)
+- **File patterns**: Follows `*.test.ts` naming (or `*.test.js` for bootstrap)
+- **Directory structure**: Proper placement in `test/unit/`, `test/lib/`, etc.
+- **Mock patterns**: Proper Sinon stubbing of SDK methods
+- **Coverage configuration**: Correct nyc setup (watch for `inlcude` typo)
+- **Test isolation**: Proper `beforeEach`/`afterEach` with `sinon.restore()`
+- **No real API calls**: All external dependencies properly mocked
+
+### Contentstack API Integration (Real Patterns)
+- **SDK usage**: Proper `managementSDKClient` and fluent API chaining
+- **Authentication**: Correct `configHandler` and token alias handling
+- **Rate limiting compliance**: 
+  - Batch spacing (minimum 1 second between batches)
+  - 429 retry handling with exponential backoff
+  - Pagination throttling for variants
+- **Error handling**: Proper `handleAndLogError` usage and user-friendly messages
+- **Configuration**: Proper regional endpoint and management token handling
+
+### Import/Export Module Architecture
+- **BaseClass extension**: Proper inheritance from import/export BaseClass
+- **Batch processing**: Correct use of `makeConcurrentCall` and `logMsgAndWaitIfRequired`
+- **Module organization**: Proper entity-specific module structure
+- **Configuration handling**: Proper `ModuleClassParams` usage
+- **Progress feedback**: Appropriate user feedback during long operations
+
+### Security and Best Practices
+- **Token security**: No API keys or tokens logged or committed
+- **Input validation**: Proper validation of user inputs and flags
+- **Error exposure**: No sensitive information in error messages
+- **File permissions**: Proper handling of file system operations
+- **Process management**: Appropriate use of `process.exit(1)` for critical failures
+
+### Performance Considerations
+- **Concurrent processing**: Proper use of `Promise.allSettled` for batch operations
+- **Memory management**: Appropriate handling of large datasets
+- **Rate limiting**: Compliance with Contentstack API limits (10 req/sec)
+- **Batch sizing**: Appropriate batch sizes for different operations
+- **Progress tracking**: Efficient progress reporting without performance impact
+
+### Package-Specific Patterns
+- **Plugin vs Library**: Correct `oclif.commands` configuration for plugin packages
+- **Command compilation**: Proper build pipeline (`tsc` → `lib/commands` → `oclif manifest`)
+- **Dependency management**: Correct use of shared vs package-specific dependencies
+- **Test variations**: Handles different test patterns per package (JS vs TS, different structures)
+
+## Review Execution
+
+### Automated Checks
+1. **Lint compliance**: ESLint and TypeScript compiler checks
+2. **Test coverage**: nyc coverage thresholds (where enforced)
+3. **Build verification**: Successful compilation to `lib/` directories
+4. **Dependency audit**: No security vulnerabilities in dependencies
+
+### Manual Review Focus Areas
+1. **API integration patterns**: Verify proper SDK usage and error handling
+2. **Rate limiting implementation**: Check for proper throttling mechanisms
+3. **Test quality**: Verify comprehensive mocking and error scenario coverage
+4. **Command usability**: Ensure clear help text and examples
+5. **Monorepo consistency**: Check for consistent patterns across packages
+
+### Common Issues to Flag
+- **Coverage config typos**: `"inlcude"` instead of `"include"` in `.nycrc.json`
+- **Inconsistent TypeScript**: Mixed strict mode usage without migration plan
+- **Real API calls in tests**: Any unmocked external dependencies
+- **Missing rate limiting**: API calls without proper throttling
+- **Build artifacts committed**: Any `lib/` directories in version control
+- **Inconsistent error handling**: Not using utilities error handling patterns
diff --git a/.cursor/commands/execute-tests.md b/.cursor/commands/execute-tests.md
new file mode 100644
index 000000000..7cde58bbd
--- /dev/null
+++ b/.cursor/commands/execute-tests.md
@@ -0,0 +1,107 @@
+---
+name: execute-tests
+description: Run tests by scope, file, or module with intelligent filtering for this pnpm monorepo
+---
+
+# Execute Tests Command
+
+## Usage Patterns
+
+### Monorepo-Wide Testing
+- `/execute-tests` - Run all tests across all packages
+- `/execute-tests --coverage` - Run all tests with nyc coverage report
+- `/execute-tests --parallel` - Run package tests in parallel using pnpm
+
+### Package-Specific Testing
+- `/execute-tests packages/contentstack-audit/` - Run tests for specific package
+- `/execute-tests packages/contentstack-import/` - Run import package tests
+- `/execute-tests packages/contentstack-export/` - Run export package tests
+- `/execute-tests contentstack-migration` - Run tests by package name (shorthand)
+
+### Scope-Based Testing
+- `/execute-tests unit` - Run unit tests only (`test/unit/**/*.test.ts`)
+- `/execute-tests commands` - Run command tests (`test/commands/**/*.test.ts`)
+- `/execute-tests services` - Run service layer tests
+- `/execute-tests modules` - Run import/export module tests
+
+### File Pattern Testing
+- `/execute-tests *.test.ts` - Run all TypeScript tests
+- `/execute-tests *.test.js` - Run JavaScript tests (bootstrap package)
+- `/execute-tests test/unit/services/` - Run tests for specific directory
+
+### Watch and Development
+- `/execute-tests --watch` - Run tests in watch mode with file monitoring
+- `/execute-tests --debug` - Run tests with debug output enabled
+- `/execute-tests --bail` - Stop on first test failure
+
+## Intelligent Filtering
+
+### Repository-Aware Detection
+- **Test patterns**: Primarily `*.test.ts`, some `*.test.js` (bootstrap), rare `*.spec.ts`
+- **Directory structures**: `test/unit/`, `test/lib/`, `test/seed/`, `test/commands/`
+- **Package variations**: Different test layouts per package
+- **Build exclusion**: Ignores `lib/` directories (compiled artifacts)
+
+### Monorepo Integration
+- **pnpm workspace support**: Uses `pnpm -r --filter` for package targeting
+- **Dependency awareness**: Understands package interdependencies
+- **Parallel execution**: Leverages pnpm's parallel capabilities
+- **Selective testing**: Can target specific packages or file patterns
+
+### Framework Detection
+- **Mocha configuration**: Respects `.mocharc.json` files per package
+- **TypeScript compilation**: Handles `pretest: tsc -p test` scripts
+- **Coverage integration**: Works with nyc configuration (`.nycrc.json`)
+- **Test helpers**: Detects and includes test initialization files
+
+## Execution Examples
+
+### Common Workflows
+```bash
+# Run all tests with coverage
+/execute-tests --coverage
+
+# Test specific package during development
+/execute-tests packages/contentstack-import/ --watch
+
+# Run only unit tests across all packages
+/execute-tests unit
+
+# Test import/export modules specifically
+/execute-tests modules --coverage
+
+# Debug failing tests in audit package
+/execute-tests packages/contentstack-audit/ --debug --bail
+```
+
+### Package-Specific Commands Generated
+```bash
+# For contentstack-import package
+cd packages/contentstack-import && pnpm test
+
+# For all packages with coverage
+pnpm -r --filter './packages/*' run test:coverage
+
+# For specific test file
+cd packages/contentstack-export && npx mocha test/unit/export/modules/stack.test.ts
+```
+
+## Configuration Awareness
+
+### Mocha Integration
+- Respects individual package `.mocharc.json` configurations
+- Handles TypeScript compilation via `ts-node/register`
+- Supports test helpers and initialization files
+- Manages timeout settings per package
+
+### Coverage Integration
+- Uses nyc for coverage reporting
+- Respects `.nycrc.json` configurations (with typo detection)
+- Generates HTML, text, and lcov reports
+- Handles TypeScript source mapping
+
+### pnpm Workspace Features
+- Leverages workspace dependency resolution
+- Supports filtered execution by package patterns
+- Enables parallel test execution across packages
+- Respects package-specific scripts and configurations
diff --git a/.cursor/rules/contentstack-cli.mdc b/.cursor/rules/contentstack-cli.mdc
new file mode 100644
index 000000000..b7ec1b81b
--- /dev/null
+++ b/.cursor/rules/contentstack-cli.mdc
@@ -0,0 +1,165 @@
+---
+description: 'Contentstack CLI specific patterns and API integration'
+globs: ['**/import/**/*.ts', '**/export/**/*.ts', '**/modules/**/*.ts', '**/services/**/*.ts', '**/utils/**/*.ts']
+alwaysApply: false
+---
+
+# Contentstack CLI Standards
+
+## API Integration
+
+- Use `@contentstack/cli-utilities` for SDK factory: `managementSDKClient(config)`
+- Stack-scoped API access: `stackAPIClient.asset()`, `stackAPIClient.extension()`
+- Fluent SDK chaining: `stack.contentType().entry().query().find()`
+- Custom HTTP for variants: `apiClient.put/get` with path strings
+
+## Authentication
+
+- Use `@contentstack/cli-utilities` for token management
+- Management token alias: `configHandler.get('tokens.<alias>')`
+- OAuth context: `configHandler.get('userUid'|'email'|'oauthOrgUid')`
+- Authentication check: `isAuthenticated()` before operations
+- Never log API keys or tokens in console or files
+
+## Rate Limiting - Multiple Mechanisms
+
+### Batch Spacing (Import/Export)
+```typescript
+// ✅ GOOD - Ensure minimum 1 second between batches
+async logMsgAndWaitIfRequired(processName: string, start: number): Promise<void> {
+  const end = Date.now();
+  const exeTime = end - start;
+  if (exeTime < 1000) await this.delay(1000 - exeTime);
+}
+```
+
+### 429 Retry (Branches)
+```typescript
+// ✅ GOOD - Handle 429 with retry
+export async function handleErrorMsg(err, retryCallback?: () => Promise<any>) {
+  if (err?.status === 429 || err?.response?.status === 429) {
+    await new Promise((resolve) => setTimeout(resolve, 1000)); // 1 sec delay
+    if (retryCallback) {
+      return retryCallback(); // Retry the request
+    }
+  }
+}
+```
+
+### Variant Pagination Throttle
+```typescript
+// ✅ GOOD - Throttle variant API requests
+if (requestTime < 1000) {
+  await delay(1000 - requestTime);
+}
+```
+
+## Error Handling
+
+### Standard Pattern
+```typescript
+// ✅ GOOD - Use handleAndLogError from utilities
+try {
+  const result = await this.stack.contentType().entry().fetch();
+} catch (error) {
+  handleAndLogError(error);
+  this.logAndPrintErrorDetails(error, config);
+}
+```
+
+### User-Friendly Errors
+```typescript
+// ✅ GOOD - User-facing error display
+cliux.print(errorMessage, { color: 'red' });
+// For critical failures
+process.exit(1);
+```
+
+## Module Architecture (Import/Export)
+
+### BaseClass Pattern
+```typescript
+// ✅ GOOD - Extend BaseClass for entity modules
+export class ContentTypes extends BaseClass {
+  constructor(params: ModuleClassParams) {
+    super(params);
+    // Entity-specific initialization
+  }
+
+  async import(): Promise<void> {
+    // Use this.makeConcurrentCall for batching
+    // Use this.logMsgAndWaitIfRequired for rate limiting
+  }
+}
+```
+
+### Batch Processing
+```typescript
+// ✅ GOOD - Concurrent batch processing
+const batches = chunk(apiContent, batchSize);
+for (const batch of batches) {
+  const start = Date.now();
+  await this.makeConcurrentCall(batch, this.processItem.bind(this));
+  await this.logMsgAndWaitIfRequired('Processing', start, batches.length, batchIndex);
+}
+```
+
+## Configuration Patterns
+
+### Import/Export Config
+```typescript
+// ✅ GOOD - Use configHandler for management tokens
+const config = {
+  host: configHandler.get('region.cma'),
+  managementTokenAlias: flags.alias,
+  stackApiKey: flags['stack-api-key'],
+  rateLimit: 5, // Default rate limit
+};
+```
+
+### Regional Configuration
+```typescript
+// ✅ GOOD - Handle regional endpoints
+const defaultConfig = {
+  host: 'https://api.contentstack.io',
+  cdn: 'https://cdn.contentstack.io',
+  // Regional developer hub URLs
+};
+```
+
+## Testing Patterns
+
+### SDK Mocking
+```typescript
+// ✅ GOOD - Mock stack client methods
+const mockStackClient = {
+  fetch: sinon.stub().resolves({ name: 'Test Stack', uid: 'stack-uid' }),
+  locale: sinon.stub().returns({
+    query: sinon.stub().returns({
+      find: sinon.stub().resolves({ items: [], count: 0 }),
+    }),
+  }),
+};
+```
+
+### Error Simulation
+```typescript
+// ✅ GOOD - Test error handling
+it('should handle 429 rate limit', async () => {
+  const error = { status: 429 };
+  mockClient.fetch.rejects(error);
+  // Test retry logic
+});
+```
+
+## Package-Specific Patterns
+
+### Plugin vs Library
+- **Plugin packages**: Have `oclif.commands` in package.json
+- **Library packages** (e.g., variants): No OCLIF commands, consumed by other packages
+
+### Monorepo Structure
+- Commands: `packages/*/src/commands/cm/**/*.ts`
+- Modules: `packages/*/src/{import,export,modules}/**/*.ts`
+- Utilities: `packages/*/src/utils/**/*.ts`
+- Built artifacts: `packages/*/lib/**` (not source)
diff --git a/.cursor/rules/dev-workflow.md b/.cursor/rules/dev-workflow.md
new file mode 100644
index 000000000..04ac39af6
--- /dev/null
+++ b/.cursor/rules/dev-workflow.md
@@ -0,0 +1,148 @@
+---
+description: "Core development workflow and TDD patterns - always applied"
+globs: ["**/*.ts", "**/*.js", "**/*.json"]
+alwaysApply: true
+---
+
+# Development Workflow
+
+## Monorepo Structure
+
+### Package Organization
+- **11 plugin packages** under `packages/`
+- **pnpm workspaces** with `workspaces: ["packages/*"]`
+- **Shared dependencies**: `@contentstack/cli-command`, `@contentstack/cli-utilities`
+- **Build artifacts**: `lib/` directory (compiled from `src/`)
+
+### Development Commands
+```bash
+# Install dependencies for all packages
+pnpm install
+
+# Run command across all packages
+pnpm -r --filter './packages/*' <command>
+
+# Work on specific package
+cd packages/contentstack-import
+pnpm test
+```
+
+## TDD Workflow - MANDATORY
+
+1. **RED** → Write ONE failing test in `test/unit/**/*.test.ts`
+2. **GREEN** → Write minimal code in `src/` to pass
+3. **REFACTOR** → Improve code quality while keeping tests green
+
+### Test-First Examples
+```typescript
+// ✅ GOOD - Write test first
+describe('ImportService', () => {
+  it('should import content types', async () => {
+    // Arrange - Set up mocks
+    mockStackClient.contentType.returns({
+      create: sinon.stub().resolves({ uid: 'ct-uid' })
+    });
+
+    // Act - Call the method
+    const result = await importService.importContentTypes();
+
+    // Assert - Verify behavior
+    expect(result.success).to.be.true;
+    expect(mockStackClient.contentType).to.have.been.called;
+  });
+});
+```
+
+## Critical Rules
+
+### Testing Standards
+- **NO implementation before tests** - Test-driven development only
+- **Coverage aspiration**: 80% minimum (not uniformly enforced)
+- **Mock all external dependencies** - No real API calls in tests
+- **Use Mocha + Chai + Sinon** - Standard testing stack
+
+### Code Quality
+- **TypeScript configuration**: Varies by package (strict mode aspirational)
+- **NO test.skip or .only in commits** - Clean test suites only
+- **Proper error handling** - Use `handleAndLogError` from utilities
+
+### Build Process
+```bash
+# Standard build process
+pnpm run build    # tsc compilation
+pnpm run test     # Run test suite
+oclif manifest    # Generate OCLIF manifest
+```
+
+## Package-Specific Patterns
+
+### Plugin Packages
+- Have `oclif.commands` in `package.json`
+- Commands in `src/commands/cm/**/*.ts`
+- Built commands in `lib/commands/`
+- Extend `@contentstack/cli-command`
+
+### Library Packages (e.g., variants)
+- No OCLIF commands configuration
+- Pure TypeScript libraries
+- Consumed by other packages
+- `main` points to `lib/index.js`
+
+## Quick Reference
+
+For detailed patterns, see skills:
+- `@skills/testing` - Mocha, Chai, Sinon patterns and TDD workflow
+- `@skills/contentstack-cli` - API integration, rate limiting, authentication
+- `@skills/oclif-commands` - Command structure, base classes, validation
+
+## Development Checklist
+
+### Before Starting Work
+- [ ] Identify target package in `packages/`
+- [ ] Check existing tests in `test/unit/`
+- [ ] Understand command structure if working on commands
+- [ ] Set up proper TypeScript configuration
+
+### During Development
+- [ ] Write failing test first
+- [ ] Implement minimal code to pass
+- [ ] Mock external dependencies (SDK, file system, etc.)
+- [ ] Use proper error handling patterns
+- [ ] Follow naming conventions (kebab-case files, PascalCase classes)
+
+### Before Committing
+- [ ] All tests pass: `pnpm test`
+- [ ] No `.only` or `.skip` in test files
+- [ ] Build succeeds: `pnpm run build`
+- [ ] TypeScript compilation clean
+- [ ] Proper error handling implemented
+
+## Common Patterns
+
+### Service Layer Architecture
+```typescript
+// ✅ GOOD - Separate concerns
+export default class ImportCommand extends Command {
+  async run(): Promise<void> {
+    const config = this.buildConfig();
+    const service = new ImportService(config);
+    
+    try {
+      await service.execute();
+      this.log('Import completed successfully');
+    } catch (error) {
+      handleAndLogError(error);
+    }
+  }
+}
+```
+
+### Rate Limiting Compliance
+```typescript
+// ✅ GOOD - Respect API limits
+async processBatch(batch: Item[]): Promise<void> {
+  const start = Date.now();
+  await this.makeConcurrentCall(batch, this.processItem);
+  await this.logMsgAndWaitIfRequired('Processing', start);
+}
+```
diff --git a/.cursor/rules/oclif-commands.mdc b/.cursor/rules/oclif-commands.mdc
new file mode 100644
index 000000000..ac186ff52
--- /dev/null
+++ b/.cursor/rules/oclif-commands.mdc
@@ -0,0 +1,219 @@
+---
+description: 'OCLIF command development patterns and CLI best practices'
+globs: ['**/commands/**/*.ts']
+alwaysApply: false
+---
+
+# OCLIF Command Standards
+
+## Command Structure
+
+### Standard Command Pattern
+```typescript
+// ✅ GOOD - Standard command structure
+import { Command } from '@contentstack/cli-command';
+
+export default class ImportCommand extends Command {
+  static description = 'Import content from a stack';
+  
+  static examples: string[] = [
+    'csdx cm:stacks:import --stack-api-key <key> --data-dir <path>',
+    'csdx cm:stacks:import --alias <alias> --config <config-path>',
+  ];
+  
+  static flags = {
+    // Define flags using utilities
+  };
+  
+  async run(): Promise<void> {
+    // Main command logic
+  }
+}
+```
+
+## Base Classes Available
+
+### BaseCommand (Audit Package)
+```typescript
+// ✅ GOOD - Extend BaseCommand for shared functionality
+export abstract class BaseCommand<T extends typeof Command> extends Command {
+  static baseFlags: FlagInput = {
+    config: Flags.string({ char: 'c', description: 'Config path' }),
+    'data-dir': Flags.string({ char: 'd', description: 'Data directory' }),
+    'show-console-output': Flags.boolean({ description: 'Show console output' }),
+  };
+
+  public async init(): Promise<void> {
+    await super.init();
+    const { args, flags } = await this.parse({
+      flags: this.ctor.flags,
+      baseFlags: (super.ctor as typeof BaseCommand).baseFlags,
+      // ...
+    });
+  }
+}
+```
+
+### BaseCommand (Export-to-CSV Package)
+```typescript
+// ✅ GOOD - Lightweight base with command context
+export abstract class BaseCommand extends Command {
+  public commandContext!: CommandContext;
+
+  public async init(): Promise<void> {
+    await super.init();
+    this.commandContext = this.createCommandContext();
+    log.debug('Command initialized', this.commandContext);
+  }
+
+  protected async catch(err: Error & { exitCode?: number }): Promise<unknown> {
+    log.debug('Command error caught', { ...this.commandContext, error: err.message });
+    return super.catch(err);
+  }
+}
+```
+
+## Command Patterns
+
+### Import Commands
+- Use `@contentstack/cli-command` Command base
+- Parse with `ImportCommand` type for config validation
+- Handle authentication via `configHandler` and `isAuthenticated`
+- Delegate to service layer modules
+
+### Direct Extension Pattern
+```typescript
+// ✅ GOOD - Most packages extend Command directly
+export default class BranchMerge extends Command {
+  static description = 'Merge branches';
+  
+  async run(): Promise<void> {
+    const { flags } = await this.parse(BranchMerge);
+    // Command-specific logic
+  }
+}
+```
+
+## OCLIF Configuration
+
+### Package.json Setup
+```json
+{
+  "oclif": {
+    "commands": "./lib/commands",
+    "bin": "csdx",
+    "topicSeparator": ":"
+  }
+}
+```
+
+### Command Topics
+- All commands use `cm` topic: `cm:stacks:import`, `cm:branches:merge`
+- Built commands live in `lib/commands` (compiled from `src/commands`)
+- Optional `csdxConfig.shortCommandName` for abbreviated names
+
+## Error Handling
+
+### Standard Error Pattern
+```typescript
+// ✅ GOOD - Use handleAndLogError from utilities
+try {
+  await this.executeCommand();
+} catch (error) {
+  handleAndLogError(error);
+  this.logAndPrintErrorDetails(error, config);
+}
+```
+
+### User-Friendly Messages
+```typescript
+// ✅ GOOD - Clear user feedback
+cliux.print('Operation completed successfully', { color: 'green' });
+cliux.print('Error occurred', { color: 'red' });
+
+// For critical failures
+process.exit(1);
+```
+
+## Validation Patterns
+
+### Early Validation
+```typescript
+// ✅ GOOD - Validate flags early
+async run(): Promise<void> {
+  const { flags } = await this.parse(MyCommand);
+  
+  // Validate required combinations
+  if (!flags.alias && !flags['stack-api-key']) {
+    this.error('Either --alias or --stack-api-key is required');
+  }
+  
+  // Proceed with validated input
+}
+```
+
+### Authentication Check
+```typescript
+// ✅ GOOD - Check authentication before operations
+if (!isAuthenticated()) {
+  this.error('Please login first using: csdx auth:login');
+}
+```
+
+## Progress and Logging
+
+### Progress Feedback
+```typescript
+// ✅ GOOD - Provide user feedback
+this.log('Starting import process...');
+cliux.print('Processing entries...', { color: 'blue' });
+
+// Use progress bars for long operations
+const progressBar = cliux.progress.start(total);
+progressBar.increment();
+progressBar.stop();
+```
+
+### Debug Logging
+```typescript
+// ✅ GOOD - Use structured logging
+log.debug('Command initialized', { 
+  command: this.id, 
+  flags: this.flags 
+});
+```
+
+## Command Delegation
+
+### Service Layer Separation
+```typescript
+// ✅ GOOD - Commands orchestrate, services implement
+async run(): Promise<void> {
+  const config = this.buildConfig();
+  const service = new ImportService(config);
+  
+  try {
+    await service.execute();
+    this.log('Import completed successfully');
+  } catch (error) {
+    this.handleError(error);
+  }
+}
+```
+
+## Testing Commands
+
+### OCLIF Test Support
+```typescript
+// ✅ GOOD - Use @oclif/test for command testing
+import { test } from '@oclif/test';
+
+describe('cm:stacks:import', () => {
+  test
+    .stdout()
+    .command(['cm:stacks:import', '--help'])
+    .it('shows help', ctx => {
+      expect(ctx.stdout).to.contain('Import content from a stack');
+    });
+});
+```
diff --git a/.cursor/rules/testing.mdc b/.cursor/rules/testing.mdc
new file mode 100644
index 000000000..7fc3a7c93
--- /dev/null
+++ b/.cursor/rules/testing.mdc
@@ -0,0 +1,266 @@
+---
+description: 'Testing patterns and TDD workflow'
+globs: ['**/test/**/*.ts', '**/test/**/*.js', '**/__tests__/**/*.ts', '**/*.spec.ts', '**/*.test.ts']
+alwaysApply: true
+---
+
+# Testing Standards
+
+## Framework Stack
+
+### Primary Testing Tools
+- **Mocha** - Test runner (used across all packages)
+- **Chai** - Assertion library
+- **Sinon** - Mocking and stubbing
+- **@oclif/test** - Command testing support
+- **nyc** - Code coverage
+
+### Package-Specific Tools
+- **nock** - HTTP mocking (migration package)
+- **rewire** - Module patching (import package)
+
+## Test File Patterns
+
+### Naming Conventions
+- **Primary**: `*.test.ts` (dominant pattern)
+- **Alternative**: `*.spec.ts` (less common)
+- **Bootstrap exception**: `*.test.js` (JavaScript tests)
+
+### Directory Structure
+```
+packages/*/
+├── test/unit/**/*.test.ts    # Most packages
+├── test/lib/**/*.test.ts     # clone package
+├── test/seed/**/*.test.ts    # seed package
+└── test/commands/**/*.test.ts # command-specific tests
+```
+
+## Mocha Configuration
+
+### Standard Setup (.mocharc.json)
+```json
+{
+  "require": [
+    "test/helpers/init.js",
+    "ts-node/register", 
+    "source-map-support/register"
+  ],
+  "recursive": true,
+  "timeout": 30000,
+  "spec": "test/**/*.test.ts"
+}
+```
+
+### TypeScript Compilation
+```json
+// package.json scripts
+{
+  "pretest": "tsc -p test",
+  "test": "nyc --extension .ts mocha"
+}
+```
+
+## Mocking Patterns
+
+### Sinon SDK Mocking
+```typescript
+// ✅ GOOD - Mock Contentstack SDK methods
+const mockStackClient = {
+  fetch: sinon.stub().resolves({ 
+    name: 'Test Stack', 
+    uid: 'stack-uid', 
+    org_uid: 'org-uid' 
+  }),
+  locale: sinon.stub().returns({
+    query: sinon.stub().returns({
+      find: sinon.stub().resolves({
+        items: [{ 
+          uid: 'locale-1', 
+          name: 'English (United States)', 
+          code: 'en-us' 
+        }],
+        count: 1,
+      }),
+    }),
+  }),
+};
+```
+
+### Module Stubbing
+```typescript
+// ✅ GOOD - Stub sibling modules
+beforeEach(() => {
+  sinon.stub(mapModule, 'processEntries').resolves([]);
+  sinon.stub(configModule, 'getConfig').returns(mockConfig);
+});
+
+afterEach(() => {
+  sinon.restore();
+});
+```
+
+### HTTP Mocking (Migration)
+```typescript
+// ✅ GOOD - Use nock for HTTP mocking
+import nock from 'nock';
+
+beforeEach(() => {
+  nock('https://api.contentstack.io')
+    .get('/v3/stacks')
+    .reply(200, { stacks: [] });
+});
+```
+
+## Coverage Configuration
+
+### NYC Setup (.nycrc.json)
+```json
+{
+  "extension": [".ts"],
+  "include": ["src/**/*.ts"],
+  "exclude": ["**/*.test.ts", "**/*.spec.ts"],
+  "reporter": ["text", "html", "lcov"],
+  "all": true
+}
+```
+
+### Coverage Targets
+- **Team aspiration**: 80% minimum coverage
+- **Current enforcement**: Inconsistent across packages
+- **Note**: Some packages have `check-coverage: false`
+- **Typo alert**: Several `.nycrc.json` files have `"inlcude"` instead of `"include"`
+
+## Test Structure
+
+### Standard Test Pattern
+```typescript
+// ✅ GOOD - Comprehensive test structure
+describe('ContentTypes Module', () => {
+  let mockStackClient: any;
+  let contentTypes: ContentTypes;
+
+  beforeEach(() => {
+    mockStackClient = createMockStackClient();
+    contentTypes = new ContentTypes({
+      stackAPIClient: mockStackClient,
+      importConfig: mockConfig,
+    });
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  describe('import()', () => {
+    it('should import content types successfully', async () => {
+      // Arrange
+      mockStackClient.contentType.returns({
+        create: sinon.stub().resolves({ uid: 'ct-uid' })
+      });
+
+      // Act
+      await contentTypes.import();
+
+      // Assert
+      expect(mockStackClient.contentType).to.have.been.called;
+    });
+
+    it('should handle API errors gracefully', async () => {
+      // Arrange
+      const error = new Error('API Error');
+      mockStackClient.contentType.throws(error);
+
+      // Act & Assert
+      await expect(contentTypes.import()).to.be.rejectedWith('API Error');
+    });
+  });
+});
+```
+
+## Command Testing
+
+### OCLIF Test Pattern
+```typescript
+// ✅ GOOD - Test commands with @oclif/test
+import { test } from '@oclif/test';
+
+describe('cm:stacks:import', () => {
+  test
+    .stdout()
+    .command(['cm:stacks:import', '--help'])
+    .it('shows help message', ctx => {
+      expect(ctx.stdout).to.contain('Import content from a stack');
+    });
+
+  test
+    .stderr()
+    .command(['cm:stacks:import'])
+    .exit(2)
+    .it('fails without required flags');
+});
+```
+
+## Error Testing
+
+### Rate Limit Testing
+```typescript
+// ✅ GOOD - Test rate limiting behavior
+it('should handle 429 rate limit errors', async () => {
+  const rateLimitError = { status: 429 };
+  mockClient.fetch.onFirstCall().rejects(rateLimitError);
+  mockClient.fetch.onSecondCall().resolves(mockResponse);
+
+  const result = await service.fetchWithRetry();
+  
+  expect(mockClient.fetch).to.have.been.calledTwice;
+  expect(result).to.equal(mockResponse);
+});
+```
+
+### Authentication Testing
+```typescript
+// ✅ GOOD - Test authentication scenarios
+it('should handle token expiration', async () => {
+  const authError = { status: 401, message: 'Unauthorized' };
+  mockClient.fetch.rejects(authError);
+
+  await expect(service.makeRequest()).to.be.rejectedWith('Unauthorized');
+});
+```
+
+## Test Data Management
+
+### Mock Data Organization
+```typescript
+// ✅ GOOD - Organize test data
+const mockData = {
+  contentTypes: [
+    { uid: 'ct1', title: 'Content Type 1' },
+    { uid: 'ct2', title: 'Content Type 2' },
+  ],
+  entries: [
+    { uid: 'entry1', title: 'Entry 1', content_type: 'ct1' },
+  ],
+};
+```
+
+### Test Helpers
+```typescript
+// ✅ GOOD - Create reusable test utilities
+export function createMockStackClient() {
+  return {
+    fetch: sinon.stub(),
+    contentType: sinon.stub(),
+    entry: sinon.stub(),
+    // ... other methods
+  };
+}
+```
+
+## Critical Testing Rules
+
+- **No real API calls** - Always mock external dependencies
+- **Test both success and failure paths** - Cover error scenarios
+- **Mock at service boundaries** - Don't mock internal implementation details
+- **Use proper cleanup** - Always restore stubs in afterEach
+- **Test command validation** - Verify flag validation and error messages
diff --git a/.cursor/rules/typescript.mdc b/.cursor/rules/typescript.mdc
new file mode 100644
index 000000000..d3ff4774b
--- /dev/null
+++ b/.cursor/rules/typescript.mdc
@@ -0,0 +1,259 @@
+---
+description: 'TypeScript strict mode standards and naming conventions'
+globs: ['**/*.ts', '**/*.tsx']
+alwaysApply: false
+---
+
+# TypeScript Standards
+
+## Configuration
+
+### Root Configuration
+```json
+// tsconfig.json - Baseline configuration
+{
+  "compilerOptions": {
+    "strict": true,
+    "module": "commonjs",
+    "target": "es2016",
+    "declaration": true,
+    "outDir": "lib",
+    "rootDir": "src"
+  }
+}
+```
+
+### Package-Level Variations
+```json
+// Most packages override with:
+{
+  "compilerOptions": {
+    "strict": false,           // ⚠️ Relaxed for legacy code
+    "noImplicitAny": true,     // ✅ Still enforce type annotations
+    "target": "es2017",
+    "allowJs": true           // Mixed JS/TS support
+  }
+}
+```
+
+### Modern Packages (Bootstrap, Variants)
+```json
+// TypeScript 5.x with stricter settings
+{
+  "compilerOptions": {
+    "strict": true,
+    "target": "es2020",
+    "moduleResolution": "node16"
+  }
+}
+```
+
+## Naming Conventions (Actual Usage)
+
+### Files
+- **Primary pattern**: `kebab-case.ts` (`base-class.ts`, `import-config-handler.ts`)
+- **Single-word modules**: `stack.ts`, `locales.ts`, `entries.ts`
+- **Commands**: Follow OCLIF topic structure (`cm/stacks/import.ts`)
+
+### Classes
+```typescript
+// ✅ GOOD - PascalCase for classes
+export class ImportCommand extends Command { }
+export class BaseClass { }
+export class ExportStack { }
+export class ContentTypes { }
+```
+
+### Functions and Methods
+```typescript
+// ✅ GOOD - camelCase for functions
+export async function fetchAllEntries(): Promise<Entry[]> { }
+async logMsgAndWaitIfRequired(): Promise<void> { }
+createCommandContext(): CommandContext { }
+```
+
+### Constants
+```typescript
+// ✅ GOOD - SCREAMING_SNAKE_CASE for constants
+const DEFAULT_RATE_LIMIT = 5;
+const MAX_RETRY_ATTEMPTS = 3;
+const API_BASE_URL = 'https://api.contentstack.io';
+```
+
+### Interfaces and Types
+```typescript
+// ✅ GOOD - PascalCase for types
+export interface ModuleClassParams {
+  importConfig: ImportConfig;
+  stackAPIClient: ManagementStack;
+}
+
+export type ApiOptions = {
+  host?: string;
+  timeout?: number;
+};
+
+export type EnvType = 'development' | 'staging' | 'production';
+```
+
+## Import/Export Patterns
+
+### ES Modules (Preferred)
+```typescript
+// ✅ GOOD - ES import/export syntax
+import { Command } from '@contentstack/cli-command';
+import type { ImportConfig } from '../types';
+import { managementSDKClient } from '@contentstack/cli-utilities';
+
+export default class ImportCommand extends Command { }
+export { ImportConfig, ApiOptions };
+```
+
+### Default Exports
+```typescript
+// ✅ GOOD - Default export for commands and main classes
+export default class ImportCommand extends Command { }
+export default class BaseClass { }
+```
+
+### Named Exports
+```typescript
+// ✅ GOOD - Named exports for utilities and types
+export async function delay(ms: number): Promise<void> { }
+export interface ConfigOptions { }
+export type ModuleType = 'import' | 'export';
+```
+
+## Type Definitions
+
+### Local Types
+```typescript
+// ✅ GOOD - Define types close to usage
+export interface ImportOptions {
+  stackApiKey: string;
+  dataDir: string;
+  rateLimit?: number;
+}
+
+export type BatchResult = {
+  success: boolean;
+  errors: Error[];
+  processedCount: number;
+};
+```
+
+### Type Organization
+```typescript
+// ✅ GOOD - Organize types in dedicated files
+// src/types/index.ts
+export interface ImportConfig { }
+export interface ExportConfig { }
+export type ModuleClassParams = { };
+```
+
+## Strict Mode Compliance
+
+### Function Return Types
+```typescript
+// ✅ GOOD - Explicit return types
+export async function fetchEntries(): Promise<Entry[]> {
+  return await this.stack.entry().query().find();
+}
+
+export function createConfig(): ImportConfig {
+  return {
+    stackApiKey: '',
+    dataDir: './data',
+  };
+}
+```
+
+### Null Safety
+```typescript
+// ✅ GOOD - Handle null/undefined explicitly
+function processEntry(entry: Entry | null): void {
+  if (!entry) {
+    throw new Error('Entry is required');
+  }
+  // Process entry safely
+}
+```
+
+### Type Guards
+```typescript
+// ✅ GOOD - Use type guards for runtime checks
+function isImportConfig(config: unknown): config is ImportConfig {
+  return typeof config === 'object' && 
+         config !== null && 
+         'stackApiKey' in config;
+}
+```
+
+## Error Handling Types
+
+### Custom Error Classes
+```typescript
+// ✅ GOOD - Typed error classes
+export class ContentstackApiError extends Error {
+  constructor(
+    message: string,
+    public readonly statusCode?: number,
+    public readonly cause?: Error
+  ) {
+    super(message);
+    this.name = 'ContentstackApiError';
+  }
+}
+```
+
+### Error Union Types
+```typescript
+// ✅ GOOD - Model expected errors
+type ApiResult<T> = {
+  success: true;
+  data: T;
+} | {
+  success: false;
+  error: string;
+  statusCode: number;
+};
+```
+
+## Migration Strategy
+
+### Gradual Strict Mode Adoption
+```typescript
+// ✅ ACCEPTABLE - Gradual migration approach
+// @ts-ignore for legacy code during migration
+// TODO: Remove @ts-ignore and fix types
+// @ts-ignore
+const legacyResult = oldApiCall();
+```
+
+### Type Assertions (Use Sparingly)
+```typescript
+// ⚠️ USE CAREFULLY - Type assertions when necessary
+const config = unknownConfig as ImportConfig;
+
+// ✅ BETTER - Use type guards instead
+if (isImportConfig(unknownConfig)) {
+  const config = unknownConfig; // TypeScript knows the type
+}
+```
+
+## Package-Specific Patterns
+
+### Command Packages
+- Extend `@contentstack/cli-command` types
+- Use OCLIF flag types from utilities
+- Define command-specific interfaces
+
+### Library Packages (Variants)
+- No OCLIF dependencies
+- Pure TypeScript interfaces
+- Consumed by other packages
+
+### Test Files
+- Use `any` sparingly for mock objects
+- Prefer typed mocks when possible
+- Test type safety with TypeScript compiler
diff --git a/.github/workflows/release-v2-beta-plugins.yml b/.github/workflows/release-v2-beta-plugins.yml
index 359fbb78f..482b0a9bc 100644
--- a/.github/workflows/release-v2-beta-plugins.yml
+++ b/.github/workflows/release-v2-beta-plugins.yml
@@ -135,17 +135,10 @@ jobs:
           package: ./packages/contentstack-branches/package.json
           tag: beta
 
-      - name: Create Beta Release
-        id: create_release
-        env:
-          GITHUB_TOKEN: ${{ secrets.PKG_TOKEN }}
-          VERSION: ${{ steps.publish-core.outputs.version }}
-        run: |
-          # Get the previous beta release for comparison
-          PREVIOUS_BETA=$(gh release list --limit 10 | grep 'beta' | head -1 | cut -f1)
-
-          if [ -n "$PREVIOUS_BETA" ]; then
-            gh release create v"$VERSION" --title "Beta Release $VERSION" --notes-from-tag "$PREVIOUS_BETA" --prerelease
-          else
-            gh release create v"$VERSION" --title "Beta Release $VERSION" --generate-notes --prerelease
-          fi
+      # Query Export
+      - name: Publishing query-export (Beta)
+        uses: JS-DevTools/npm-publish@v3
+        with:
+          token: ${{ secrets.NPM_TOKEN }}
+          package: ./packages/contentstack-query-export/package.json
+          tag: beta
diff --git a/.github/workflows/unit-test.yml b/.github/workflows/unit-test.yml
index 464a114fc..62c048f9b 100644
--- a/.github/workflows/unit-test.yml
+++ b/.github/workflows/unit-test.yml
@@ -62,3 +62,7 @@ jobs:
       - name: Run tests for Contentstack Branches
         working-directory: ./packages/contentstack-branches
         run: npm run test:unit
+
+      - name: Run tests for Contentstack Query Export
+        working-directory: ./packages/contentstack-query-export
+        run: npm run test:unit
diff --git a/.talismanrc b/.talismanrc
index 4406a0bb9..6782a04a4 100644
--- a/.talismanrc
+++ b/.talismanrc
@@ -1,6 +1,26 @@
 fileignoreconfig:
-  - filename: packages/contentstack-import/src/utils/import-config-handler.ts
-    checksum: 3194f537cee8041f07a7ea91cdc6351c84e400766696d9c3cf80b98f99961f76
   - filename: pnpm-lock.yaml
-    checksum: cea25dedde40bf962d825a088e505113c997ae666a4385d3eec0ae3f9f5d1404
+    checksum: 0942b9ee7e4b284bfd9f0a2258ca8281cf8569b60dd293e08abf64373db12d59
+  - filename: packages/contentstack-import/src/types/index.ts
+    checksum: 0fd8f3f82bd754848b1ab90980c0c1316b62eddfe5d2a6e6216e0ff8429591ca
+  - filename: packages/contentstack-import/test/unit/utils/extension-helper.test.ts
+    checksum: 569e0b434372b8b97d3d4db906cf3e9e56eb546899f490e008e2d3107285e1f3
+  - filename: packages/contentstack-import/test/unit/import/modules/locales.test.ts
+    checksum: 55e481f09920dcf4d5d6cfe50fb8e20caffb2fd80673b3e08507192f76b46700
+  - filename: packages/contentstack-import/src/config/index.ts
+    checksum: 5939e3cb57b9b2046072dcc144c9526831a9b8088ef30289d0de605ca46f97c4
+  - filename: packages/contentstack-variants/src/types/export-config.ts
+    checksum: e6df2394b6acb1f1ff30ed18baca686ba5b36c9de03b529f9980acbec4c8c8fc
+  - filename: packages/contentstack-export/src/config/index.ts
+    checksum: 0a800b44643b5cb808c575b5d029fae1769a8f16aa3ead06246da293400b82db
+  - filename: packages/contentstack-import/src/import/modules/publishing-rules.ts
+    checksum: 429a803bc18e691db93bae3df1714071d0face6441b82cb938a83e8bf94ae14c
+  - filename: packages/contentstack-import/src/types/default-config.ts
+    checksum: c117d060d6979540a1bb6ae20ad6ad6d43e9b15a6909291f76ed60b11e5f793d
+  - filename: packages/contentstack-import/test/unit/import/modules/publishing-rules.test.ts
+    checksum: 0fcbff5dab2f9e594fe2a316c3c96e8d86bcd5d72e7c1f9eb35c0e3458f87817
+  - filename: packages/contentstack-export/src/types/default-config.ts
+    checksum: 18d499426bec295034b6012d934c6ac82933656add43b3ca48c1f81a2fd98245
+  - filename: packages/contentstack-export/src/types/index.ts
+    checksum: 71f02ac11507c61222a661caf228dfd54ffdc6c57e4cc631f66598ecd617852b
 version: '1.0'
diff --git a/packages/contentstack-asset-management/README.md b/packages/contentstack-asset-management/README.md
deleted file mode 100644
index 87867c247..000000000
--- a/packages/contentstack-asset-management/README.md
+++ /dev/null
@@ -1,49 +0,0 @@
-# @contentstack/cli-asset-management
-
-Asset Management 2.0 API adapter for Contentstack CLI export and import. Used by the export and import plugins when Asset Management (AM 2.0) is enabled. To learn how to export and import content in Contentstack, refer to the [Migration guide](https://www.contentstack.com/docs/developers/cli/migration/).
-
-[![License](https://img.shields.io/npm/l/@contentstack/cli)](https://github.com/contentstack/cli/blob/main/LICENSE)
-
-<!-- toc -->
-* [@contentstack/cli-asset-management](#contentstackcli-asset-management)
-* [Overview](#overview)
-* [Usage](#usage)
-* [Exports](#exports)
-<!-- tocstop -->
-
-# Overview
-
-This package provides:
-
-- **AssetManagementAdapter** – HTTP client for the Asset Management API (spaces, assets, folders, fields, asset types).
-- **exportSpaceStructure** – Exports space metadata and full workspace structure (metadata, folders, assets, fields, asset types) for linked workspaces.
-- **Types** – `AssetManagementExportOptions`, `LinkedWorkspace`, `IAssetManagementAdapter`, and related types for export/import integration.
-
-# Usage
-
-This package is consumed by the export and import plugins. When using the export CLI with the `--asset-management` flag (or when the host app enables AM 2.0), the export plugin calls `exportSpaceStructure` with linked workspaces and options:
-
-```ts
-import { exportSpaceStructure } from '@contentstack/cli-asset-management';
-
-await exportSpaceStructure({
-  linkedWorkspaces,
-  exportDir,
-  branchName: 'main',
-  assetManagementUrl,
-  org_uid,
-  context,
-  progressManager,
-  progressProcessName,
-  updateStatus,
-  downloadAsset, // optional
-});
-```
-
-# Exports
-
-| Export | Description |
-|--------|-------------|
-| `exportSpaceStructure` | Async function to export space structure for given linked workspaces. |
-| `AssetManagementAdapter` | Class to call the Asset Management API (getSpace, getWorkspaceFields, getWorkspaceAssets, etc.). |
-| Types from `./types` | `AssetManagementExportOptions`, `ExportSpaceOptions`, `ChunkedJsonWriteOptions`, `LinkedWorkspace`, `SpaceResponse`, `FieldsResponse`, `AssetTypesResponse`, and related API types. |
diff --git a/packages/contentstack-asset-management/src/constants/index.ts b/packages/contentstack-asset-management/src/constants/index.ts
index 9d6bca636..f7f0ff0c8 100644
--- a/packages/contentstack-asset-management/src/constants/index.ts
+++ b/packages/contentstack-asset-management/src/constants/index.ts
@@ -35,7 +35,17 @@ export const CHUNK_FILE_SIZE_MB = FALLBACK_AM_CHUNK_FILE_SIZE_MB;
 export const AM_MAIN_PROCESS_NAME = 'Asset Management 2.0';
 
 /**
- * Process names for Asset Management 2.0 export progress (for tick labels).
+ * Process names for Asset Management 2.0 export/import progress.
+ *
+ * In the new per-space layout each entry below corresponds to a single row in
+ * the multibar:
+ *   - {@link AM_FIELDS} / {@link AM_ASSET_TYPES} are the shared bootstrap rows
+ *     (one execution per org, ahead of per-space work).
+ *   - {@link AM_IMPORT_FIELDS} / {@link AM_IMPORT_ASSET_TYPES} are the import
+ *     equivalents.
+ *   - One additional row per space is added dynamically via
+ *     {@link getSpaceProcessName} and ticks include folders + metadata + asset
+ *     transfer for that space.
  */
 export const PROCESS_NAMES = {
   AM_SPACE_METADATA: 'Space metadata',
@@ -51,6 +61,38 @@ export const PROCESS_NAMES = {
   AM_IMPORT_ASSETS: 'Import assets',
 } as const;
 
+/**
+ * Maximum visual length of a per-space process row label. The CLIProgressManager
+ * truncates anything over 20 characters; reserve 6 chars for the `Space ` prefix
+ * so the trailing space uid keeps 14 chars before truncation.
+ */
+const SPACE_PROCESS_NAME_PREFIX = 'Space ';
+const SPACE_PROCESS_NAME_MAX_UID_LEN = 14;
+
+/**
+ * Returns the multibar row label for a single AM 2.0 space.
+ * The label is bounded so CLIProgressManager.formatProcessName doesn't truncate
+ * it mid-string; the full uid is still used for tick item labels and structured
+ * logs, only the row label itself is shortened for display.
+ */
+export function getSpaceProcessName(spaceUid: string): string {
+  const safeUid = spaceUid ?? '';
+  const trimmed =
+    safeUid.length > SPACE_PROCESS_NAME_MAX_UID_LEN
+      ? safeUid.substring(0, SPACE_PROCESS_NAME_MAX_UID_LEN)
+      : safeUid;
+  return `${SPACE_PROCESS_NAME_PREFIX}${trimmed}`;
+}
+
+/**
+ * Detects whether a process name belongs to a per-space progress row, used by
+ * the export/import strategy registries to aggregate counts for the final
+ * summary across all spaces.
+ */
+export function isSpaceProcessName(processName: string): boolean {
+  return typeof processName === 'string' && processName.startsWith(SPACE_PROCESS_NAME_PREFIX);
+}
+
 /**
  * Status messages for each process (exporting, fetching, importing, failed).
  */
diff --git a/packages/contentstack-asset-management/src/export/asset-types.ts b/packages/contentstack-asset-management/src/export/asset-types.ts
index 6223b38d5..bd6c5f17c 100644
--- a/packages/contentstack-asset-management/src/export/asset-types.ts
+++ b/packages/contentstack-asset-management/src/export/asset-types.ts
@@ -7,6 +7,8 @@ import { getArrayFromResponse } from '../utils/export-helpers';
 import { PROCESS_NAMES } from '../constants/index';
 
 export default class ExportAssetTypes extends AssetManagementExportAdapter {
+  protected processName: string = PROCESS_NAMES.AM_ASSET_TYPES;
+
   constructor(apiConfig: AssetManagementAPIConfig, exportContext: ExportContext) {
     super(apiConfig, exportContext);
   }
@@ -24,7 +26,13 @@ export default class ExportAssetTypes extends AssetManagementExportAdapter {
     } else {
       log.debug(`Writing ${items.length} shared asset types`, this.exportContext.context);
     }
-    await this.writeItemsToChunkedJson(dir, 'asset-types.json', 'asset_types', ['uid', 'title', 'category', 'file_extension'], items);
-    this.tick(true, PROCESS_NAMES.AM_ASSET_TYPES, null);
+    await this.writeItemsToChunkedJson(
+      dir,
+      'asset-types.json',
+      'asset_types',
+      ['uid', 'title', 'category', 'file_extension'],
+      items,
+    );
+    this.tick(true, `asset_types (${items.length})`, null);
   }
 }
diff --git a/packages/contentstack-asset-management/src/export/assets.ts b/packages/contentstack-asset-management/src/export/assets.ts
index acd0f1676..dc8587111 100644
--- a/packages/contentstack-asset-management/src/export/assets.ts
+++ b/packages/contentstack-asset-management/src/export/assets.ts
@@ -32,11 +32,17 @@ export default class ExportAssets extends AssetManagementExportAdapter {
       this.getWorkspaceAssets(workspace.space_uid, workspace.uid),
     ]);
 
+    const assetItems = getAssetItems(assetsData);
+    const downloadableCount = assetItems.filter((asset) => Boolean(asset.url && (asset.uid ?? asset._uid))).length;
+    // Per-space total: 1 folder write + 1 metadata write + N per-asset downloads.
+    // The shared module-level total is just a placeholder before this point; update
+    // it now so the multibar row shows real progress as downloads tick in.
+    this.progressOrParent?.updateProcessTotal?.(this.processName, 2 + downloadableCount);
+
     await writeFile(pResolve(assetsDir, 'folders.json'), JSON.stringify(folders, null, 2));
     this.tick(true, `folders: ${workspace.space_uid}`, null);
     log.debug(`Wrote folders.json for space ${workspace.space_uid}`, this.exportContext.context);
 
-    const assetItems = getAssetItems(assetsData);
     log.debug(
       assetItems.length === 0
         ? `No assets for space ${workspace.space_uid}, wrote empty assets.json`
@@ -60,7 +66,7 @@ export default class ExportAssets extends AssetManagementExportAdapter {
         : `Wrote ${assetItems.length} asset metadata record(s) for space ${workspace.space_uid}`,
       this.exportContext.context,
     );
-    this.tick(true, `assets: ${workspace.space_uid} (${assetItems.length})`, null);
+    this.tick(true, `metadata: ${workspace.space_uid} (${assetItems.length})`, null);
 
     log.debug(`Starting binary downloads for space ${workspace.space_uid}`, this.exportContext.context);
     await this.downloadWorkspaceAssets(assetsData, assetsDir, workspace.space_uid);
@@ -87,8 +93,6 @@ export default class ExportAssets extends AssetManagementExportAdapter {
       `Asset downloads: securedAssets=${securedAssets}, concurrency=${this.downloadAssetsBatchConcurrency}`,
       this.exportContext.context,
     );
-    let lastError: string | null = null;
-    let allSuccess = true;
     let downloadOk = 0;
     let downloadFail = 0;
 
@@ -118,24 +122,25 @@ export default class ExportAssets extends AssetManagementExportAdapter {
         const filePath = pResolve(assetFolderPath, filename);
         await writeStreamToFile(nodeStream, filePath);
         downloadOk += 1;
+        // Per-asset tick so the per-space progress bar moves in real time.
+        this.tick(true, `asset: ${filename}`, null);
         log.debug(`Downloaded asset ${uid} → ${filePath}`, this.exportContext.context);
       } catch (e) {
-        allSuccess = false;
         downloadFail += 1;
-        lastError = (e as Error)?.message ?? PROCESS_STATUS[PROCESS_NAMES.AM_DOWNLOADS].FAILED;
+        const err = (e as Error)?.message ?? PROCESS_STATUS[PROCESS_NAMES.AM_DOWNLOADS].FAILED;
+        this.tick(false, `asset: ${filename}`, err);
         log.debug(`Failed to download asset ${uid}: ${e}`, this.exportContext.context);
       }
     });
 
-    this.tick(allSuccess, `downloads: ${spaceUid}`, lastError);
     log.info(
-      allSuccess
+      downloadFail === 0
         ? `Finished downloading ${downloadOk} asset file(s) for space ${spaceUid}`
         : `Asset downloads for space ${spaceUid} completed with errors: ${downloadOk} succeeded, ${downloadFail} failed`,
       this.exportContext.context,
     );
     log.debug(
-      `Asset downloads finished for space ${spaceUid}: ok=${downloadOk}, failed=${downloadFail}, allSuccess=${allSuccess}`,
+      `Asset downloads finished for space ${spaceUid}: ok=${downloadOk}, failed=${downloadFail}`,
       this.exportContext.context,
     );
   }
diff --git a/packages/contentstack-asset-management/src/export/base.ts b/packages/contentstack-asset-management/src/export/base.ts
index 055d2d3ba..856781653 100644
--- a/packages/contentstack-asset-management/src/export/base.ts
+++ b/packages/contentstack-asset-management/src/export/base.ts
@@ -18,7 +18,7 @@ export class AssetManagementExportAdapter extends AssetManagementAdapter {
   protected readonly exportContext: ExportContext;
   protected progressManager: CLIProgressManager | null = null;
   protected parentProgressManager: CLIProgressManager | null = null;
-  protected readonly processName: string = AM_MAIN_PROCESS_NAME;
+  protected processName: string = AM_MAIN_PROCESS_NAME;
 
   constructor(apiConfig: AssetManagementAPIConfig, exportContext: ExportContext) {
     super(apiConfig);
@@ -30,6 +30,15 @@ export class AssetManagementExportAdapter extends AssetManagementAdapter {
     this.parentProgressManager = parent;
   }
 
+  /**
+   * Override the default progress process name for {@link tick}/{@link updateStatus}
+   * calls. Used by the per-space orchestrator so each module's ticks land on the
+   * row for the space currently being exported.
+   */
+  public setProcessName(name: string): void {
+    this.processName = name;
+  }
+
   protected get progressOrParent(): CLIProgressManager | null {
     return this.parentProgressManager ?? this.progressManager;
   }
diff --git a/packages/contentstack-asset-management/src/export/fields.ts b/packages/contentstack-asset-management/src/export/fields.ts
index fd997e5e5..08e1caa6e 100644
--- a/packages/contentstack-asset-management/src/export/fields.ts
+++ b/packages/contentstack-asset-management/src/export/fields.ts
@@ -7,6 +7,8 @@ import { getArrayFromResponse } from '../utils/export-helpers';
 import { PROCESS_NAMES } from '../constants/index';
 
 export default class ExportFields extends AssetManagementExportAdapter {
+  protected processName: string = PROCESS_NAMES.AM_FIELDS;
+
   constructor(apiConfig: AssetManagementAPIConfig, exportContext: ExportContext) {
     super(apiConfig, exportContext);
   }
@@ -25,6 +27,6 @@ export default class ExportFields extends AssetManagementExportAdapter {
       log.debug(`Writing ${items.length} shared fields`, this.exportContext.context);
     }
     await this.writeItemsToChunkedJson(dir, 'fields.json', 'fields', ['uid', 'title', 'display_type'], items);
-    this.tick(true, PROCESS_NAMES.AM_FIELDS, null);
+    this.tick(true, `fields (${items.length})`, null);
   }
 }
diff --git a/packages/contentstack-asset-management/src/export/spaces.ts b/packages/contentstack-asset-management/src/export/spaces.ts
index 24a5a088d..1147cdb1a 100644
--- a/packages/contentstack-asset-management/src/export/spaces.ts
+++ b/packages/contentstack-asset-management/src/export/spaces.ts
@@ -4,8 +4,7 @@ import { log, CLIProgressManager, configHandler, handleAndLogError } from '@cont
 
 import type { AssetManagementExportOptions, AssetManagementAPIConfig } from '../types/asset-management-api';
 import type { ExportContext } from '../types/export-types';
-import { AssetManagementAdapter } from '../utils/asset-management-api-adapter';
-import { AM_MAIN_PROCESS_NAME, PROCESS_NAMES, PROCESS_STATUS } from '../constants/index';
+import { AM_MAIN_PROCESS_NAME, PROCESS_NAMES, getSpaceProcessName } from '../constants/index';
 import ExportAssetTypes from './asset-types';
 import ExportFields from './fields';
 import ExportWorkspace from './workspaces';
@@ -55,12 +54,18 @@ export class ExportSpaces {
     await mkdir(spacesRootPath, { recursive: true });
     log.debug(`Spaces root path: ${spacesRootPath}`, context);
 
-    const totalSteps = 2 + linkedWorkspaces.length * 4;
     const progress = this.createProgress();
-    progress.addProcess(AM_MAIN_PROCESS_NAME, totalSteps);
-    progress
-      .startProcess(AM_MAIN_PROCESS_NAME)
-      .updateStatus(PROCESS_STATUS[PROCESS_NAMES.AM_FIELDS].FETCHING, AM_MAIN_PROCESS_NAME);
+    // Multibar layout: two shared bootstrap rows + one row per space. Per-space
+    // totals start at 1 and are bumped to (2 + downloadableCount) inside
+    // ExportAssets.start once we know the asset count for that space.
+    progress.addProcess(PROCESS_NAMES.AM_FIELDS, 1);
+    progress.addProcess(PROCESS_NAMES.AM_ASSET_TYPES, 1);
+    const spaceProcessNames = new Map<string, string>();
+    for (const ws of linkedWorkspaces) {
+      const spaceProcess = getSpaceProcessName(ws.space_uid);
+      spaceProcessNames.set(ws.space_uid, spaceProcess);
+      progress.addProcess(spaceProcess, 1);
+    }
 
     const apiConfig: AssetManagementAPIConfig = {
       baseURL: assetManagementUrl,
@@ -82,39 +87,67 @@ export class ExportSpaces {
     await mkdir(sharedAssetTypesDir, { recursive: true });
 
     const firstSpaceUid = linkedWorkspaces[0].space_uid;
+    let bootstrapFailed = false;
+    let anySpaceFailed = false;
     try {
+      progress.startProcess(PROCESS_NAMES.AM_FIELDS);
+      progress.startProcess(PROCESS_NAMES.AM_ASSET_TYPES);
+
       const exportAssetTypes = new ExportAssetTypes(apiConfig, exportContext);
       exportAssetTypes.setParentProgressManager(progress);
       const exportFields = new ExportFields(apiConfig, exportContext);
       exportFields.setParentProgressManager(progress);
-      await Promise.all([exportAssetTypes.start(firstSpaceUid), exportFields.start(firstSpaceUid)]);
+      try {
+        await Promise.all([exportAssetTypes.start(firstSpaceUid), exportFields.start(firstSpaceUid)]);
+        progress.completeProcess(PROCESS_NAMES.AM_FIELDS, true);
+        progress.completeProcess(PROCESS_NAMES.AM_ASSET_TYPES, true);
+      } catch (bootstrapErr) {
+        bootstrapFailed = true;
+        progress.completeProcess(PROCESS_NAMES.AM_FIELDS, false);
+        progress.completeProcess(PROCESS_NAMES.AM_ASSET_TYPES, false);
+        throw bootstrapErr;
+      }
 
       for (const ws of linkedWorkspaces) {
-        progress.updateStatus(`Exporting space: ${ws.space_uid}...`, AM_MAIN_PROCESS_NAME);
+        const spaceProcess = spaceProcessNames.get(ws.space_uid)!;
+        progress.startProcess(spaceProcess);
         log.debug(`Exporting space: ${ws.space_uid}`, context);
         const spaceDir = pResolve(spacesRootPath, ws.space_uid);
         try {
           const exportWorkspace = new ExportWorkspace(apiConfig, exportContext);
           exportWorkspace.setParentProgressManager(progress);
-          await exportWorkspace.start(ws, spaceDir, branchName || 'main');
+          await exportWorkspace.start(ws, spaceDir, branchName || 'main', spaceProcess);
+          progress.completeProcess(spaceProcess, true);
           log.debug(`Exported workspace structure for space ${ws.space_uid}`, context);
         } catch (err) {
+          // Per-space failure: mark the row failed and continue with the next
+          // space so partial export results are preserved (matches import).
+          anySpaceFailed = true;
           log.debug(`Failed to export workspace for space ${ws.space_uid}: ${err}`, context);
-          progress.tick(
-            false,
-            `space: ${ws.space_uid}`,
-            (err as Error)?.message ?? PROCESS_STATUS[PROCESS_NAMES.AM_SPACE_METADATA].FAILED,
-            AM_MAIN_PROCESS_NAME,
+          handleAndLogError(
+            err,
+            { ...(context as Record<string, unknown>), spaceUid: ws.space_uid },
+            `Failed to export space ${ws.space_uid}`,
           );
-          throw err;
+          progress.completeProcess(spaceProcess, false);
         }
       }
 
-      progress.completeProcess(AM_MAIN_PROCESS_NAME, true);
-      log.info('Asset Management export completed successfully', context);
+      log.info(
+        anySpaceFailed
+          ? 'Asset Management export completed with errors in one or more spaces'
+          : 'Asset Management export completed successfully',
+        context,
+      );
       log.debug('Asset Management 2.0 export completed', context);
     } catch (err) {
-      progress.completeProcess(AM_MAIN_PROCESS_NAME, false);
+      if (!bootstrapFailed) {
+        // Mark any spaces that hadn't been processed as failed so the multibar
+        // doesn't leave dangling pending rows.
+        for (const [, spaceProcess] of spaceProcessNames) {
+          progress.completeProcess(spaceProcess, false);
+        }
+      }
       handleAndLogError(err, { ...(context as Record<string, unknown>) }, 'Asset Management export failed');
       throw err;
     }
diff --git a/packages/contentstack-asset-management/src/export/workspaces.ts b/packages/contentstack-asset-management/src/export/workspaces.ts
index c2f5bb4f1..0d45196e1 100644
--- a/packages/contentstack-asset-management/src/export/workspaces.ts
+++ b/packages/contentstack-asset-management/src/export/workspaces.ts
@@ -6,16 +6,33 @@ import type { AssetManagementAPIConfig, LinkedWorkspace } from '../types/asset-m
 import type { ExportContext } from '../types/export-types';
 import { AssetManagementExportAdapter } from './base';
 import ExportAssets from './assets';
-import { PROCESS_NAMES } from '../constants/index';
 
 export default class ExportWorkspace extends AssetManagementExportAdapter {
   constructor(apiConfig: AssetManagementAPIConfig, exportContext: ExportContext) {
     super(apiConfig, exportContext);
   }
 
-  async start(workspace: LinkedWorkspace, spaceDir: string, branchName: string): Promise<void> {
+  /**
+   * Run the export pipeline for a single space.
+   *
+   * The optional `spaceProcessName` is the multibar row label that ticks
+   * (folder write + metadata write + per-asset downloads) should land on. The
+   * orchestrator passes the per-space row produced by `getSpaceProcessName`;
+   * if omitted the default {@link processName} (the AM main row) is used so
+   * direct callers keep working.
+   */
+  async start(
+    workspace: LinkedWorkspace,
+    spaceDir: string,
+    branchName: string,
+    spaceProcessName?: string,
+  ): Promise<void> {
     await this.init();
 
+    if (spaceProcessName) {
+      this.setProcessName(spaceProcessName);
+    }
+
     log.debug(`Starting export for AM space ${workspace.space_uid}`, this.exportContext.context);
 
     const spaceResponse = await this.getSpace(workspace.space_uid);
@@ -35,11 +52,13 @@ export default class ExportWorkspace extends AssetManagementExportAdapter {
       log.warn(`Could not write ${metadataPath}: ${e}`, this.exportContext.context);
       throw e;
     }
-    this.tick(true, `space: ${workspace.space_uid}`, null);
     log.debug(`Space metadata written for ${workspace.space_uid}`, this.exportContext.context);
 
     const assetsExporter = new ExportAssets(this.apiConfig, this.exportContext);
     if (this.progressOrParent) assetsExporter.setParentProgressManager(this.progressOrParent);
+    if (spaceProcessName) {
+      assetsExporter.setProcessName(spaceProcessName);
+    }
     await assetsExporter.start(workspace, spaceDir);
     log.debug(`Exported workspace structure for space ${workspace.space_uid}`, this.exportContext.context);
   }
diff --git a/packages/contentstack-asset-management/src/import/asset-types.ts b/packages/contentstack-asset-management/src/import/asset-types.ts
index 71f5fbbac..0e943edee 100644
--- a/packages/contentstack-asset-management/src/import/asset-types.ts
+++ b/packages/contentstack-asset-management/src/import/asset-types.ts
@@ -24,6 +24,11 @@ type AssetTypeToCreate = { uid: string; payload: Record<string, unknown> };
  * 5. Strip read-only/computed keys from the POST body before creating new asset types.
  */
 export default class ImportAssetTypes extends AssetManagementImportAdapter {
+  protected processName: string = PROCESS_NAMES.AM_IMPORT_ASSET_TYPES;
+  private successCount = 0;
+  private failureCount = 0;
+  private skippedCount = 0;
+
   constructor(apiConfig: AssetManagementAPIConfig, importContext: ImportContext) {
     super(apiConfig, importContext);
   }
@@ -40,15 +45,13 @@ export default class ImportAssetTypes extends AssetManagementImportAdapter {
 
     if (!existsSync(indexPath)) {
       log.info('No shared asset types to import (index missing)', this.importContext.context);
+      this.tick(true, 'asset_types (0)', null);
       return;
     }
 
     const existingByUid = await this.loadExistingAssetTypesMap();
 
-    this.updateStatus(
-      PROCESS_STATUS[PROCESS_NAMES.AM_IMPORT_ASSET_TYPES].IMPORTING,
-      PROCESS_NAMES.AM_IMPORT_ASSET_TYPES,
-    );
+    this.updateStatus(PROCESS_STATUS[PROCESS_NAMES.AM_IMPORT_ASSET_TYPES].IMPORTING);
 
     await forEachChunkedJsonStore<Record<string, unknown>>(
       dir,
@@ -64,6 +67,12 @@ export default class ImportAssetTypes extends AssetManagementImportAdapter {
         await this.importAssetTypesCreates(toCreate);
       },
     );
+
+    this.tick(
+      this.failureCount === 0,
+      `asset_types: ${this.successCount} created, ${this.skippedCount} skipped, ${this.failureCount} failed`,
+      this.failureCount > 0 ? PROCESS_STATUS[PROCESS_NAMES.AM_IMPORT_ASSET_TYPES].FAILED : null,
+    );
   }
 
   /** Org-level asset types keyed by uid for diff; empty map if list API fails. */
@@ -111,7 +120,7 @@ export default class ImportAssetTypes extends AssetManagementImportAdapter {
             this.importContext.context,
           );
         }
-        this.tick(true, `asset-type: ${uid} (skipped, already exists)`, null, PROCESS_NAMES.AM_IMPORT_ASSET_TYPES);
+        this.skippedCount += 1;
         continue;
       }
 
@@ -125,15 +134,10 @@ export default class ImportAssetTypes extends AssetManagementImportAdapter {
     await runInBatches(toCreate, this.apiConcurrency, async ({ uid, payload }) => {
       try {
         await this.createAssetType(payload as any);
-        this.tick(true, `asset-type: ${uid}`, null, PROCESS_NAMES.AM_IMPORT_ASSET_TYPES);
+        this.successCount += 1;
         log.debug(`Imported asset type: ${uid}`, this.importContext.context);
       } catch (e) {
-        this.tick(
-          false,
-          `asset-type: ${uid}`,
-          (e as Error)?.message ?? PROCESS_STATUS[PROCESS_NAMES.AM_IMPORT_ASSET_TYPES].FAILED,
-          PROCESS_NAMES.AM_IMPORT_ASSET_TYPES,
-        );
+        this.failureCount += 1;
         log.debug(`Failed to import asset type ${uid}: ${e}`, this.importContext.context);
       }
     });
diff --git a/packages/contentstack-asset-management/src/import/assets.ts b/packages/contentstack-asset-management/src/import/assets.ts
index b69721245..d665353b2 100644
--- a/packages/contentstack-asset-management/src/import/assets.ts
+++ b/packages/contentstack-asset-management/src/import/assets.ts
@@ -127,58 +127,62 @@ export default class ImportAssets extends AssetManagementImportAdapter {
     log.debug(`Assets directory: ${assetsDir}`, this.importContext.context);
 
     // -----------------------------------------------------------------------
-    // 1. Import folders
+    // 0. Pre-count folders and assets so the per-space progress row knows the
+    //    real total upfront. Each folder/asset is a single tick below.
     // -----------------------------------------------------------------------
-    const folderUidMap: Record<string, string> = {};
     const foldersFileName = this.importContext.foldersFileName ?? 'folders.json';
     const foldersFilePath = join(assetsDir, foldersFileName);
+    const folders = this.readFolders(foldersFilePath, foldersFileName);
+    const folderCount = folders.length;
 
-    if (!existsSync(foldersFilePath)) {
-      log.debug(`No ${foldersFileName} at ${foldersFilePath}, skipping folder import`, this.importContext.context);
-    }
+    const loc = this.resolveAssetsChunkedLocation(spaceDir);
+    const assetCount = loc ? this.countAssetsInChunkedStore(loc.assetsDir, loc.indexName) : 0;
 
-    if (existsSync(foldersFilePath)) {
-      let foldersData: unknown;
-      try {
-        foldersData = JSON.parse(readFileSync(foldersFilePath, 'utf8'));
-      } catch (e) {
-        log.warn(`Could not read ${foldersFileName}: ${e}`, this.importContext.context);
-      }
+    // Update the per-space row to fold + assets (min 1 so the bar shows
+    // something even for empty spaces).
+    this.progressOrParent?.updateProcessTotal?.(this.processName, Math.max(1, folderCount + assetCount));
 
-      if (foldersData) {
-        log.debug(`Reading folders from ${foldersFilePath}`, this.importContext.context);
-        const folders = getArrayFromResponse(foldersData, 'folders') as FolderRecord[];
-        this.updateStatus(PROCESS_STATUS[PROCESS_NAMES.AM_IMPORT_FOLDERS].IMPORTING, PROCESS_NAMES.AM_IMPORT_FOLDERS);
-        log.debug(
-          `Importing ${folders.length} folder(s) for space ${newSpaceUid} (concurrency=${this.importFoldersBatchConcurrency})`,
-          this.importContext.context,
-        );
-        await this.importFolders(newSpaceUid, folders, folderUidMap);
-        log.debug(
-          `Folder import phase complete: ${Object.keys(folderUidMap).length} exported folder uid(s) mapped to target`,
-          this.importContext.context,
-        );
-        log.info(
-          `Finished importing ${Object.keys(folderUidMap).length} folder(s) for space ${newSpaceUid}`,
-          this.importContext.context,
-        );
-      }
+    // -----------------------------------------------------------------------
+    // 1. Import folders
+    // -----------------------------------------------------------------------
+    const folderUidMap: Record<string, string> = {};
+
+    if (folderCount > 0) {
+      this.updateStatus(PROCESS_STATUS[PROCESS_NAMES.AM_IMPORT_FOLDERS].IMPORTING);
+      log.debug(
+        `Importing ${folderCount} folder(s) for space ${newSpaceUid} (concurrency=${this.importFoldersBatchConcurrency})`,
+        this.importContext.context,
+      );
+      await this.importFolders(newSpaceUid, folders, folderUidMap);
+      log.debug(
+        `Folder import phase complete: ${Object.keys(folderUidMap).length} exported folder uid(s) mapped to target`,
+        this.importContext.context,
+      );
+      log.info(
+        `Finished importing ${Object.keys(folderUidMap).length} folder(s) for space ${newSpaceUid}`,
+        this.importContext.context,
+      );
+    } else {
+      log.debug(`No ${foldersFileName} at ${foldersFilePath}, skipping folder import`, this.importContext.context);
     }
 
     // -----------------------------------------------------------------------
     // 2. Import assets (chunked on disk — process one chunk file at a time)
     // -----------------------------------------------------------------------
-    const loc = this.resolveAssetsChunkedLocation(spaceDir);
     if (!loc) {
       log.info(
         `No asset metadata index in ${assetsDir}; skipping file uploads for space ${newSpaceUid}`,
         this.importContext.context,
       );
       log.debug(`No assets.json index found in ${assetsDir}, skipping asset upload`, this.importContext.context);
+      // Empty space — bump current to total (1) so the row reads 100%.
+      if (folderCount === 0) {
+        this.tick(true, `space: ${newSpaceUid} (empty)`, null);
+      }
       return { uidMap, urlMap };
     }
 
-    this.updateStatus(PROCESS_STATUS[PROCESS_NAMES.AM_IMPORT_ASSETS].IMPORTING, PROCESS_NAMES.AM_IMPORT_ASSETS);
+    this.updateStatus(PROCESS_STATUS[PROCESS_NAMES.AM_IMPORT_ASSETS].IMPORTING);
     log.debug(
       `Uploading assets for space ${newSpaceUid} from ${loc.assetsDir} (index: ${loc.indexName}, concurrency=${this.uploadAssetsBatchConcurrency})`,
       this.importContext.context,
@@ -205,7 +209,7 @@ export default class ImportAssets extends AssetManagementImportAdapter {
           if (!existsSync(filePath)) {
             missingFiles += 1;
             log.warn(`Asset file not found: ${filePath}, skipping`, this.importContext.context);
-            this.tick(false, `asset: ${oldUid}`, 'File not found on disk', PROCESS_NAMES.AM_IMPORT_ASSETS);
+            this.tick(false, `asset: ${oldUid}`, 'File not found on disk');
             continue;
           }
 
@@ -239,16 +243,15 @@ export default class ImportAssets extends AssetManagementImportAdapter {
                 urlMap[asset.url] = created.url;
               }
 
-              this.tick(true, `asset: ${oldUid}`, null, PROCESS_NAMES.AM_IMPORT_ASSETS);
+              this.tick(true, `asset: ${filename}`, null);
               uploadOk += 1;
               log.debug(`Uploaded asset ${oldUid} → ${created.uid} (${filePath})`, this.importContext.context);
             } catch (e) {
               uploadFail += 1;
               this.tick(
                 false,
-                `asset: ${oldUid}`,
+                `asset: ${filename}`,
                 (e as Error)?.message ?? PROCESS_STATUS[PROCESS_NAMES.AM_IMPORT_ASSETS].FAILED,
-                PROCESS_NAMES.AM_IMPORT_ASSETS,
               );
               log.debug(`Failed to upload asset ${oldUid}: ${e}`, this.importContext.context);
             }
@@ -271,6 +274,45 @@ export default class ImportAssets extends AssetManagementImportAdapter {
     return { uidMap, urlMap };
   }
 
+  /**
+   * Read folders.json into a list, returning [] when the file is absent or
+   * unreadable. Side-effects (warnings) match the legacy in-line behaviour so
+   * callers can rely on the return as a count source.
+   */
+  private readFolders(foldersFilePath: string, foldersFileName: string): FolderRecord[] {
+    if (!existsSync(foldersFilePath)) {
+      return [];
+    }
+    try {
+      const data = JSON.parse(readFileSync(foldersFilePath, 'utf8'));
+      log.debug(`Reading folders from ${foldersFilePath}`, this.importContext.context);
+      return getArrayFromResponse(data, 'folders') as FolderRecord[];
+    } catch (e) {
+      log.warn(`Could not read ${foldersFileName}: ${e}`, this.importContext.context);
+      return [];
+    }
+  }
+
+  /**
+   * Sum the asset count across all chunk metadata files for the per-space row
+   * total. Reads `metadata.json` once (cheap aggregate); avoids streaming the
+   * full chunk payloads twice.
+   */
+  private countAssetsInChunkedStore(assetsDir: string, indexName: string): number {
+    try {
+      const fs = new FsUtility({ basePath: assetsDir, indexFileName: indexName });
+      const meta = fs.getPlainMeta();
+      let total = 0;
+      for (const value of Object.values(meta)) {
+        if (Array.isArray(value)) total += value.length;
+      }
+      return total;
+    } catch (e) {
+      log.debug(`Could not pre-count assets in ${assetsDir}: ${e}`, this.importContext.context);
+      return 0;
+    }
+  }
+
   /**
    * Creates folders respecting hierarchy: parents before children.
    * Uses multiple passes to handle arbitrary depth without requiring sorted input.
@@ -317,14 +359,13 @@ export default class ImportAssets extends AssetManagementImportAdapter {
             parent_uid: isRootParent ? undefined : folderUidMap[parentUid!],
           });
           folderUidMap[folder.uid] = created.uid;
-          this.tick(true, `folder: ${folder.uid}`, null, PROCESS_NAMES.AM_IMPORT_FOLDERS);
+          this.tick(true, `folder: ${folder.title}`, null);
           log.debug(`Created folder ${folder.uid} → ${created.uid}`, this.importContext.context);
         } catch (e) {
           this.tick(
             false,
-            `folder: ${folder.uid}`,
+            `folder: ${folder.title}`,
             (e as Error)?.message ?? PROCESS_STATUS[PROCESS_NAMES.AM_IMPORT_FOLDERS].FAILED,
-            PROCESS_NAMES.AM_IMPORT_FOLDERS,
           );
           log.debug(`Failed to create folder ${folder.uid}: ${e}`, this.importContext.context);
         }
diff --git a/packages/contentstack-asset-management/src/import/base.ts b/packages/contentstack-asset-management/src/import/base.ts
index ef1d4c0f5..24fca0918 100644
--- a/packages/contentstack-asset-management/src/import/base.ts
+++ b/packages/contentstack-asset-management/src/import/base.ts
@@ -16,7 +16,7 @@ export class AssetManagementImportAdapter extends AssetManagementAdapter {
   protected readonly importContext: ImportContext;
   protected progressManager: CLIProgressManager | null = null;
   protected parentProgressManager: CLIProgressManager | null = null;
-  protected readonly processName: string = AM_MAIN_PROCESS_NAME;
+  protected processName: string = AM_MAIN_PROCESS_NAME;
 
   constructor(apiConfig: AssetManagementAPIConfig, importContext: ImportContext) {
     super(apiConfig);
@@ -28,6 +28,15 @@ export class AssetManagementImportAdapter extends AssetManagementAdapter {
     this.parentProgressManager = parent;
   }
 
+  /**
+   * Override the default progress process name for {@link tick}/{@link updateStatus}
+   * calls. Used by the per-space orchestrator so each module's ticks land on the
+   * row for the space currently being imported.
+   */
+  public setProcessName(name: string): void {
+    this.processName = name;
+  }
+
   protected get progressOrParent(): CLIProgressManager | null {
     return this.parentProgressManager ?? this.progressManager;
   }
diff --git a/packages/contentstack-asset-management/src/import/fields.ts b/packages/contentstack-asset-management/src/import/fields.ts
index 9785906c2..2bba913f6 100644
--- a/packages/contentstack-asset-management/src/import/fields.ts
+++ b/packages/contentstack-asset-management/src/import/fields.ts
@@ -24,6 +24,11 @@ type FieldToCreate = { uid: string; payload: Record<string, unknown> };
  * 5. Strip read-only/computed keys from the POST body before creating new fields.
  */
 export default class ImportFields extends AssetManagementImportAdapter {
+  protected processName: string = PROCESS_NAMES.AM_IMPORT_FIELDS;
+  private successCount = 0;
+  private failureCount = 0;
+  private skippedCount = 0;
+
   constructor(apiConfig: AssetManagementAPIConfig, importContext: ImportContext) {
     super(apiConfig, importContext);
   }
@@ -40,12 +45,15 @@ export default class ImportFields extends AssetManagementImportAdapter {
 
     if (!existsSync(indexPath)) {
       log.info('No shared fields to import (index missing)', this.importContext.context);
+      // Single aggregate tick so the shared row in the multibar still completes
+      // even when there is nothing to import.
+      this.tick(true, 'fields (0)', null);
       return;
     }
 
     const existingByUid = await this.loadExistingFieldsMap();
 
-    this.updateStatus(PROCESS_STATUS[PROCESS_NAMES.AM_IMPORT_FIELDS].IMPORTING, PROCESS_NAMES.AM_IMPORT_FIELDS);
+    this.updateStatus(PROCESS_STATUS[PROCESS_NAMES.AM_IMPORT_FIELDS].IMPORTING);
 
     await forEachChunkedJsonStore<Record<string, unknown>>(
       dir,
@@ -61,6 +69,15 @@ export default class ImportFields extends AssetManagementImportAdapter {
         await this.importFieldsCreates(toCreate);
       },
     );
+
+    // Aggregate tick at end so the single-row shared bootstrap bar reaches 100%
+    // regardless of how many chunks/items were processed; the per-field outcome
+    // is still captured in logs.
+    this.tick(
+      this.failureCount === 0,
+      `fields: ${this.successCount} created, ${this.skippedCount} skipped, ${this.failureCount} failed`,
+      this.failureCount > 0 ? PROCESS_STATUS[PROCESS_NAMES.AM_IMPORT_FIELDS].FAILED : null,
+    );
   }
 
   /** Org-level fields keyed by uid for diff; empty map if list API fails. */
@@ -105,7 +122,7 @@ export default class ImportFields extends AssetManagementImportAdapter {
         } else {
           log.debug(`Field "${uid}" already exists with matching definition, skipping`, this.importContext.context);
         }
-        this.tick(true, `field: ${uid} (skipped, already exists)`, null, PROCESS_NAMES.AM_IMPORT_FIELDS);
+        this.skippedCount += 1;
         continue;
       }
 
@@ -119,15 +136,10 @@ export default class ImportFields extends AssetManagementImportAdapter {
     await runInBatches(toCreate, this.apiConcurrency, async ({ uid, payload }) => {
       try {
         await this.createField(payload as any);
-        this.tick(true, `field: ${uid}`, null, PROCESS_NAMES.AM_IMPORT_FIELDS);
+        this.successCount += 1;
         log.debug(`Imported field: ${uid}`, this.importContext.context);
       } catch (e) {
-        this.tick(
-          false,
-          `field: ${uid}`,
-          (e as Error)?.message ?? PROCESS_STATUS[PROCESS_NAMES.AM_IMPORT_FIELDS].FAILED,
-          PROCESS_NAMES.AM_IMPORT_FIELDS,
-        );
+        this.failureCount += 1;
         log.debug(`Failed to import field ${uid}: ${e}`, this.importContext.context);
       }
     });
diff --git a/packages/contentstack-asset-management/src/import/spaces.ts b/packages/contentstack-asset-management/src/import/spaces.ts
index 6f66d24be..01c309fba 100644
--- a/packages/contentstack-asset-management/src/import/spaces.ts
+++ b/packages/contentstack-asset-management/src/import/spaces.ts
@@ -10,7 +10,7 @@ import type {
   ImportSpacesOptions,
   SpaceMapping,
 } from '../types/asset-management-api';
-import { AM_MAIN_PROCESS_NAME } from '../constants/index';
+import { AM_MAIN_PROCESS_NAME, PROCESS_NAMES, getSpaceProcessName } from '../constants/index';
 import { AssetManagementAdapter } from '../utils/asset-management-api-adapter';
 import ImportAssetTypes from './asset-types';
 import ImportFields from './fields';
@@ -86,10 +86,18 @@ export class ImportSpaces {
       log.warn(`Could not read spaces root path ${spacesRootPath}: ${e}`, context);
     }
 
-    const totalSteps = 2 + spaceDirs.length * 2;
     const progress = this.createProgress();
-    progress.addProcess(AM_MAIN_PROCESS_NAME, totalSteps);
-    progress.startProcess(AM_MAIN_PROCESS_NAME);
+    // Multibar layout: two shared bootstrap rows + one row per space directory.
+    // Per-space totals start at 1 and are bumped to (folderCount + assetCount)
+    // inside ImportAssets.start once we know the counts for that space.
+    progress.addProcess(PROCESS_NAMES.AM_IMPORT_FIELDS, 1);
+    progress.addProcess(PROCESS_NAMES.AM_IMPORT_ASSET_TYPES, 1);
+    const spaceProcessNames = new Map<string, string>();
+    for (const spaceUid of spaceDirs) {
+      const spaceProcess = getSpaceProcessName(spaceUid);
+      spaceProcessNames.set(spaceUid, spaceProcess);
+      progress.addProcess(spaceProcess, 1);
+    }
 
     const allUidMap: Record<string, string> = {};
     const allUrlMap: Record<string, string> = {};
@@ -117,27 +125,47 @@ export class ImportSpaces {
       log.info('Started Asset Management import', context);
 
       // 1. Import shared fields
-      progress.updateStatus(`Importing shared fields...`, AM_MAIN_PROCESS_NAME);
+      progress.startProcess(PROCESS_NAMES.AM_IMPORT_FIELDS);
       const fieldsImporter = new ImportFields(apiConfig, importContext);
       fieldsImporter.setParentProgressManager(progress);
-      await fieldsImporter.start();
+      try {
+        await fieldsImporter.start();
+        progress.completeProcess(PROCESS_NAMES.AM_IMPORT_FIELDS, true);
+      } catch (e) {
+        progress.completeProcess(PROCESS_NAMES.AM_IMPORT_FIELDS, false);
+        throw e;
+      }
 
       // 2. Import shared asset types
-      progress.updateStatus('Importing shared asset types...', AM_MAIN_PROCESS_NAME);
+      progress.startProcess(PROCESS_NAMES.AM_IMPORT_ASSET_TYPES);
       const assetTypesImporter = new ImportAssetTypes(apiConfig, importContext);
       assetTypesImporter.setParentProgressManager(progress);
-      await assetTypesImporter.start();
+      try {
+        await assetTypesImporter.start();
+        progress.completeProcess(PROCESS_NAMES.AM_IMPORT_ASSET_TYPES, true);
+      } catch (e) {
+        progress.completeProcess(PROCESS_NAMES.AM_IMPORT_ASSET_TYPES, false);
+        throw e;
+      }
 
       // 3. Import each space — continue on failure so partially-imported data is never lost
       for (const spaceUid of spaceDirs) {
         const spaceDir = join(spacesRootPath, spaceUid);
-        progress.updateStatus(`Importing space: ${spaceUid}...`, AM_MAIN_PROCESS_NAME);
+        const spaceProcess = spaceProcessNames.get(spaceUid)!;
+        progress.startProcess(spaceProcess);
         log.debug(`Importing space: ${spaceUid}`, context);
 
         try {
           const workspaceImporter = new ImportWorkspace(apiConfig, importContext);
           workspaceImporter.setParentProgressManager(progress);
-          const result = await workspaceImporter.start(spaceUid, spaceDir, existingSpaceUids);
+          const result = await workspaceImporter.start(
+            spaceUid,
+            spaceDir,
+            existingSpaceUids,
+            spaceProcess,
+            configOptions.targetDefaultSpaceUid,
+            configOptions.targetDefaultWorkspaceUid,
+          );
 
           // Newly created spaces get a new uid — add so later iterations in this run see it.
           existingSpaceUids.add(result.newSpaceUid);
@@ -152,17 +180,13 @@ export class ImportSpaces {
             isDefault: result.isDefault,
           });
 
+          progress.completeProcess(spaceProcess, true);
           log.debug(`Imported space ${spaceUid} → ${result.newSpaceUid}`, context);
           spacesSucceeded += 1;
         } catch (err) {
           hasFailures = true;
           spacesFailed += 1;
-          progress.tick(
-            false,
-            `space: ${spaceUid}`,
-            (err as Error)?.message ?? 'Failed to import space',
-            AM_MAIN_PROCESS_NAME,
-          );
+          progress.completeProcess(spaceProcess, false);
           log.warn(`Failed to import space ${spaceUid}: ${err}`, context);
         }
       }
@@ -181,14 +205,20 @@ export class ImportSpaces {
         log.debug('Wrote AM 2.0 mapper files (uid, url, space-uid)', context);
       }
 
-      progress.completeProcess(AM_MAIN_PROCESS_NAME, !hasFailures);
       log.info(
         `Asset Management import finished: ${spacesSucceeded} space(s) succeeded, ${spacesFailed} failed, ${spaceDirs.length} attempted.`,
         context,
       );
-      log.debug('Asset Management 2.0 import completed', context);
+      log.debug(
+        `Asset Management 2.0 import completed (hasFailures=${hasFailures})`,
+        context,
+      );
     } catch (err) {
-      progress.completeProcess(AM_MAIN_PROCESS_NAME, false);
+      // Mark any spaces that hadn't been processed as failed so the multibar
+      // doesn't leave dangling pending rows when the bootstrap phase throws.
+      for (const [, spaceProcess] of spaceProcessNames) {
+        progress.completeProcess(spaceProcess, false);
+      }
       handleAndLogError(err, { ...(context as Record<string, unknown>) }, 'Asset Management import failed');
       throw err;
     }
diff --git a/packages/contentstack-asset-management/src/import/workspaces.ts b/packages/contentstack-asset-management/src/import/workspaces.ts
index e042b1f3b..e2143f56f 100644
--- a/packages/contentstack-asset-management/src/import/workspaces.ts
+++ b/packages/contentstack-asset-management/src/import/workspaces.ts
@@ -5,7 +5,6 @@ import { log } from '@contentstack/cli-utilities';
 import type { AssetManagementAPIConfig, ImportContext, SpaceMapping } from '../types/asset-management-api';
 import { AssetManagementImportAdapter } from './base';
 import ImportAssets from './assets';
-import { PROCESS_NAMES } from '../constants/index';
 
 type WorkspaceResult = SpaceMapping & {
   uidMap: Record<string, string>;
@@ -23,13 +22,28 @@ export default class ImportWorkspace extends AssetManagementImportAdapter {
     super(apiConfig, importContext);
   }
 
+  /**
+   * Run the import pipeline for a single space.
+   *
+   * The optional `spaceProcessName` is the multibar row label that ticks
+   * (folder creates + per-asset uploads) should land on. The orchestrator
+   * passes the per-space row produced by `getSpaceProcessName`; if omitted the
+   * default {@link processName} is used so direct callers keep working.
+   */
   async start(
     oldSpaceUid: string,
     spaceDir: string,
     existingSpaceUids: Set<string> = new Set(),
+    spaceProcessName?: string,
+    targetDefaultSpaceUid?: string,
+    targetDefaultWorkspaceUid?: string,
   ): Promise<WorkspaceResult> {
     await this.init();
 
+    if (spaceProcessName) {
+      this.setProcessName(spaceProcessName);
+    }
+
     log.debug(`Starting import for AM space directory ${oldSpaceUid}`, this.importContext.context);
 
     // Read exported metadata
@@ -48,6 +62,23 @@ export default class ImportWorkspace extends AssetManagementImportAdapter {
 
     const assetsImporter = new ImportAssets(this.apiConfig, this.importContext);
     if (this.progressOrParent) assetsImporter.setParentProgressManager(this.progressOrParent);
+    if (spaceProcessName) {
+      assetsImporter.setProcessName(spaceProcessName);
+    }
+
+    // Map source default space → existing target default space (cross-org migration).
+    // The caller supplies the uid of the pre-existing target default space; we upload
+    // source assets into it instead of creating a new space.
+    if (isDefault && targetDefaultSpaceUid) {
+      const newSpaceUid = targetDefaultSpaceUid;
+      const resolvedWorkspaceUid = targetDefaultWorkspaceUid ?? workspaceUid;
+      log.info(
+        `Source default space "${oldSpaceUid}" mapped to existing target default space "${newSpaceUid}".`,
+        this.importContext.context,
+      );
+      const { uidMap, urlMap } = await assetsImporter.start(newSpaceUid, spaceDir);
+      return { oldSpaceUid, newSpaceUid, workspaceUid: resolvedWorkspaceUid, isDefault: true, uidMap, urlMap };
+    }
 
     // Reuse: target org already has a space with the same uid as the export directory.
     if (existingSpaceUids.has(oldSpaceUid)) {
@@ -57,7 +88,9 @@ export default class ImportWorkspace extends AssetManagementImportAdapter {
       );
       const newSpaceUid = oldSpaceUid;
       const { uidMap, urlMap } = await assetsImporter.buildIdentityMappersFromExport(spaceDir);
-      this.tick(true, `space: ${oldSpaceUid} → ${newSpaceUid} (reused)`, null, PROCESS_NAMES.AM_SPACE_METADATA);
+      // Reused spaces do no folder/asset work; tick the per-space row once so it
+      // completes in the multibar.
+      this.tick(true, `space: ${oldSpaceUid} → ${newSpaceUid} (reused)`, null);
       return {
         oldSpaceUid,
         newSpaceUid,
@@ -75,7 +108,6 @@ export default class ImportWorkspace extends AssetManagementImportAdapter {
     const newSpaceUid = space.uid;
 
     log.debug(`Created space ${newSpaceUid} (old: ${oldSpaceUid})`, this.importContext.context);
-    this.tick(true, `space: ${oldSpaceUid} → ${newSpaceUid}`, null, PROCESS_NAMES.AM_SPACE_METADATA);
 
     const { uidMap, urlMap } = await assetsImporter.start(newSpaceUid, spaceDir);
 
diff --git a/packages/contentstack-asset-management/src/types/asset-management-api.ts b/packages/contentstack-asset-management/src/types/asset-management-api.ts
index 40423da89..605f54a40 100644
--- a/packages/contentstack-asset-management/src/types/asset-management-api.ts
+++ b/packages/contentstack-asset-management/src/types/asset-management-api.ts
@@ -243,6 +243,16 @@ export type ImportSpacesOptions = {
   mapperUidFileName?: string;
   mapperUrlFileName?: string;
   mapperSpaceUidFileName?: string;
+  /**
+   * UID of the already-existing default space in the target org.
+   * When set, the source default space is imported into this space instead of creating a new one.
+   */
+  targetDefaultSpaceUid?: string;
+  /**
+   * Workspace link UID of the existing default workspace in the target branch's `am_v2.linked_workspaces`.
+   * Returned in SpaceMapping.workspaceUid so downstream branch-linking logic can identify the entry correctly.
+   */
+  targetDefaultWorkspaceUid?: string;
 };
 
 /**
diff --git a/packages/contentstack-asset-management/test/unit/export/asset-types.test.ts b/packages/contentstack-asset-management/test/unit/export/asset-types.test.ts
index af052e2db..e0fd3bb1b 100644
--- a/packages/contentstack-asset-management/test/unit/export/asset-types.test.ts
+++ b/packages/contentstack-asset-management/test/unit/export/asset-types.test.ts
@@ -3,7 +3,6 @@ import sinon from 'sinon';
 
 import ExportAssetTypes from '../../../src/export/asset-types';
 import { AssetManagementExportAdapter } from '../../../src/export/base';
-import { PROCESS_NAMES } from '../../../src/constants/index';
 
 import type { AssetManagementAPIConfig } from '../../../src/types/asset-management-api';
 import type { ExportContext } from '../../../src/types/export-types';
@@ -76,13 +75,19 @@ describe('ExportAssetTypes', () => {
       expect(writeStub.firstCall.args[4]).to.deep.equal([]);
     });
 
-    it('should tick with success=true, the asset types process name, and null error', async () => {
+    it('should tick once with the asset_types summary label and null error after writing', async () => {
       sinon.stub(ExportAssetTypes.prototype, 'getWorkspaceAssetTypes').resolves(assetTypesResponse);
       const exporter = new ExportAssetTypes(apiConfig, exportContext);
       await exporter.start(spaceUid);
 
       const tickStub = (AssetManagementExportAdapter.prototype as any).tick as sinon.SinonStub;
-      expect(tickStub.firstCall.args).to.deep.equal([true, PROCESS_NAMES.AM_ASSET_TYPES, null]);
+      expect(tickStub.callCount).to.equal(1);
+      const [success, label, error] = tickStub.firstCall.args;
+      expect(success).to.be.true;
+      // Label format is `asset_types (<count>)` so the shared row carries a count
+      // summary; exact count comes from the mocked asset-types response.
+      expect(String(label)).to.match(/^asset_types \(\d+\)$/);
+      expect(error).to.be.null;
     });
   });
 });
diff --git a/packages/contentstack-asset-management/test/unit/export/assets.test.ts b/packages/contentstack-asset-management/test/unit/export/assets.test.ts
index ab6b831d4..2c4ac124e 100644
--- a/packages/contentstack-asset-management/test/unit/export/assets.test.ts
+++ b/packages/contentstack-asset-management/test/unit/export/assets.test.ts
@@ -106,11 +106,11 @@ describe('ExportAssets', () => {
 
       expect(fetchStub.callCount).to.equal(0);
       const tickStub = (AssetManagementExportAdapter.prototype as any).tick as sinon.SinonStub;
-      const downloadTick = tickStub.getCalls().find((c) => String(c.args[1]).startsWith('downloads:'));
-      expect(downloadTick).to.be.undefined;
+      const assetTicks = tickStub.getCalls().filter((c) => String(c.args[1]).startsWith('asset:'));
+      expect(assetTicks).to.have.length(0);
     });
 
-    it('should tick with success=false and the error message on download failure', async () => {
+    it('should tick per failed asset with success=false and the error message on download failure', async () => {
       sinon.stub(ExportAssets.prototype, 'getWorkspaceFolders').resolves(foldersData);
       sinon.stub(ExportAssets.prototype, 'getWorkspaceAssets').resolves(assetsResponseWithItems);
       fetchStub.rejects(new Error('network failure'));
@@ -119,12 +119,16 @@ describe('ExportAssets', () => {
       await exporter.start(workspace, spaceDir);
 
       const tickStub = (AssetManagementExportAdapter.prototype as any).tick as sinon.SinonStub;
-      const downloadTick = tickStub.getCalls().find((c) => String(c.args[1]).startsWith('downloads:'));
-      expect(downloadTick!.args[0]).to.be.false;
-      expect(downloadTick!.args[2]).to.equal('network failure');
+      const assetTicks = tickStub.getCalls().filter((c) => String(c.args[1]).startsWith('asset:'));
+      // Per-asset tick: one failure entry per attempted download.
+      expect(assetTicks.length).to.be.greaterThan(0);
+      for (const t of assetTicks) {
+        expect(t.args[0]).to.be.false;
+        expect(t.args[2]).to.equal('network failure');
+      }
     });
 
-    it('should tick with success=true and null error on successful downloads', async () => {
+    it('should tick per asset with success=true and null error on successful downloads', async () => {
       sinon.stub(ExportAssets.prototype, 'getWorkspaceFolders').resolves(foldersData);
       sinon.stub(ExportAssets.prototype, 'getWorkspaceAssets').resolves(assetsResponseWithItems);
       fetchStub.callsFake(async () => makeFetchResponse() as any);
@@ -133,9 +137,13 @@ describe('ExportAssets', () => {
       await exporter.start(workspace, spaceDir);
 
       const tickStub = (AssetManagementExportAdapter.prototype as any).tick as sinon.SinonStub;
-      const downloadTick = tickStub.getCalls().find((c) => String(c.args[1]).startsWith('downloads:'));
-      expect(downloadTick!.args[0]).to.be.true;
-      expect(downloadTick!.args[2]).to.be.null;
+      const assetTicks = tickStub.getCalls().filter((c) => String(c.args[1]).startsWith('asset:'));
+      // One successful tick per asset in the workspace.
+      expect(assetTicks).to.have.length(assetsResponseWithItems.items.length);
+      for (const t of assetTicks) {
+        expect(t.args[0]).to.be.true;
+        expect(t.args[2]).to.be.null;
+      }
     });
 
     it('should skip assets that have neither a url nor a uid', async () => {
@@ -168,9 +176,10 @@ describe('ExportAssets', () => {
 
       expect(fetchStub.firstCall.args[0]).to.equal('https://cdn.example.com/a.png');
       const tickStub = (AssetManagementExportAdapter.prototype as any).tick as sinon.SinonStub;
-      const downloadTick = tickStub.getCalls().find((c) => String(c.args[1]).startsWith('downloads:'));
-      expect(downloadTick!.args[0]).to.be.true;
-      expect(downloadTick!.args[2]).to.be.null;
+      const assetTicks = tickStub.getCalls().filter((c) => String(c.args[1]).startsWith('asset:'));
+      expect(assetTicks).to.have.length(1);
+      expect(assetTicks[0].args[0]).to.be.true;
+      expect(assetTicks[0].args[2]).to.be.null;
     });
 
     it('should download assets that use file_name, and fall back to "asset" when both names are absent', async () => {
@@ -191,8 +200,9 @@ describe('ExportAssets', () => {
       expect(fetchStub.firstCall.args[0]).to.equal('https://cdn.example.com/a1.pdf');
       expect(fetchStub.secondCall.args[0]).to.equal('https://cdn.example.com/a2.bin');
       const tickStub = (AssetManagementExportAdapter.prototype as any).tick as sinon.SinonStub;
-      const downloadTick = tickStub.getCalls().find((c) => String(c.args[1]).startsWith('downloads:'));
-      expect(downloadTick!.args[0]).to.be.true;
+      const assetTicks = tickStub.getCalls().filter((c) => String(c.args[1]).startsWith('asset:'));
+      expect(assetTicks).to.have.length(2);
+      for (const t of assetTicks) expect(t.args[0]).to.be.true;
     });
 
     it('should append authtoken to URL when securedAssets is true', async () => {
@@ -238,9 +248,10 @@ describe('ExportAssets', () => {
       await exporter.start(workspace, spaceDir);
 
       const tickStub = (AssetManagementExportAdapter.prototype as any).tick as sinon.SinonStub;
-      const downloadTick = tickStub.getCalls().find((c) => String(c.args[1]).startsWith('downloads:'));
-      expect(downloadTick!.args[0]).to.be.false;
-      expect(downloadTick!.args[2]).to.include('403');
+      const assetTicks = tickStub.getCalls().filter((c) => String(c.args[1]).startsWith('asset:'));
+      expect(assetTicks).to.have.length(1);
+      expect(assetTicks[0].args[0]).to.be.false;
+      expect(assetTicks[0].args[2]).to.include('403');
     });
 
     it('should tick with success=false and "No response body" when body is null', async () => {
@@ -254,9 +265,10 @@ describe('ExportAssets', () => {
       await exporter.start(workspace, spaceDir);
 
       const tickStub = (AssetManagementExportAdapter.prototype as any).tick as sinon.SinonStub;
-      const downloadTick = tickStub.getCalls().find((c) => String(c.args[1]).startsWith('downloads:'));
-      expect(downloadTick!.args[0]).to.be.false;
-      expect(downloadTick!.args[2]).to.equal('No response body');
+      const assetTicks = tickStub.getCalls().filter((c) => String(c.args[1]).startsWith('asset:'));
+      expect(assetTicks).to.have.length(1);
+      expect(assetTicks[0].args[0]).to.be.false;
+      expect(assetTicks[0].args[2]).to.equal('No response body');
     });
   });
 });
diff --git a/packages/contentstack-asset-management/test/unit/export/fields.test.ts b/packages/contentstack-asset-management/test/unit/export/fields.test.ts
index a039dcb75..008ceebe3 100644
--- a/packages/contentstack-asset-management/test/unit/export/fields.test.ts
+++ b/packages/contentstack-asset-management/test/unit/export/fields.test.ts
@@ -3,7 +3,6 @@ import sinon from 'sinon';
 
 import ExportFields from '../../../src/export/fields';
 import { AssetManagementExportAdapter } from '../../../src/export/base';
-import { PROCESS_NAMES } from '../../../src/constants/index';
 
 import type { AssetManagementAPIConfig } from '../../../src/types/asset-management-api';
 import type { ExportContext } from '../../../src/types/export-types';
@@ -76,13 +75,19 @@ describe('ExportFields', () => {
       expect(writeStub.firstCall.args[4]).to.deep.equal([]);
     });
 
-    it('should tick with success=true, the fields process name, and null error', async () => {
+    it('should tick once with the fields summary label and null error after writing', async () => {
       sinon.stub(ExportFields.prototype, 'getWorkspaceFields').resolves(fieldsResponse);
       const exporter = new ExportFields(apiConfig, exportContext);
       await exporter.start(spaceUid);
 
       const tickStub = (AssetManagementExportAdapter.prototype as any).tick as sinon.SinonStub;
-      expect(tickStub.firstCall.args).to.deep.equal([true, PROCESS_NAMES.AM_FIELDS, null]);
+      expect(tickStub.callCount).to.equal(1);
+      const [success, label, error] = tickStub.firstCall.args;
+      expect(success).to.be.true;
+      // Label format is `fields (<count>)` so the shared row carries a count
+      // summary; exact count comes from the mocked fields response.
+      expect(String(label)).to.match(/^fields \(\d+\)$/);
+      expect(error).to.be.null;
     });
   });
 });
diff --git a/packages/contentstack-asset-management/test/unit/export/spaces.test.ts b/packages/contentstack-asset-management/test/unit/export/spaces.test.ts
index 72e0910c9..3228ab8c1 100644
--- a/packages/contentstack-asset-management/test/unit/export/spaces.test.ts
+++ b/packages/contentstack-asset-management/test/unit/export/spaces.test.ts
@@ -7,7 +7,7 @@ import ExportAssetTypes from '../../../src/export/asset-types';
 import ExportFields from '../../../src/export/fields';
 import ExportWorkspace from '../../../src/export/workspaces';
 import { AssetManagementExportAdapter } from '../../../src/export/base';
-import { AM_MAIN_PROCESS_NAME } from '../../../src/constants/index';
+import { PROCESS_NAMES, getSpaceProcessName } from '../../../src/constants/index';
 
 import type { AssetManagementExportOptions, LinkedWorkspace } from '../../../src/types/asset-management-api';
 
@@ -42,8 +42,11 @@ describe('ExportSpaces', () => {
     sinon.stub(ExportWorkspace.prototype, 'start').resolves();
     sinon.stub(ExportWorkspace.prototype, 'setParentProgressManager');
 
+    fakeProgress.addProcess.resetHistory();
     fakeProgress.addProcess.returnsThis();
+    fakeProgress.startProcess.resetHistory();
     fakeProgress.startProcess.returnsThis();
+    fakeProgress.updateStatus.resetHistory();
     fakeProgress.updateStatus.returnsThis();
     fakeProgress.tick.reset();
     fakeProgress.completeProcess.reset();
@@ -105,31 +108,46 @@ describe('ExportSpaces', () => {
       expect(wsStub.secondCall.args[0]).to.deep.include({ uid: 'ws-2', space_uid: 'space-2' });
     });
 
-    it('should register and complete the progress process with success', async () => {
-      const totalSteps = 2 + baseOptions.linkedWorkspaces.length * 4; // 10
+    it('should register one shared row per bootstrap phase plus one row per space, and complete each on success', async () => {
       const exporter = new ExportSpaces(baseOptions);
       await exporter.start();
 
-      expect(fakeProgress.addProcess.firstCall.args).to.deep.equal([AM_MAIN_PROCESS_NAME, totalSteps]);
-      expect(fakeProgress.startProcess.firstCall.args[0]).to.equal(AM_MAIN_PROCESS_NAME);
-      expect(fakeProgress.completeProcess.firstCall.args).to.deep.equal([AM_MAIN_PROCESS_NAME, true]);
+      const addProcessCalls = fakeProgress.addProcess.getCalls().map((c) => c.args);
+      // Shared bootstrap rows + one row per linked workspace.
+      expect(addProcessCalls).to.deep.equal([
+        [PROCESS_NAMES.AM_FIELDS, 1],
+        [PROCESS_NAMES.AM_ASSET_TYPES, 1],
+        [getSpaceProcessName('space-1'), 1],
+        [getSpaceProcessName('space-2'), 1],
+      ]);
+
+      const completeArgs = fakeProgress.completeProcess.getCalls().map((c) => c.args);
+      expect(completeArgs).to.deep.include.members([
+        [PROCESS_NAMES.AM_FIELDS, true],
+        [PROCESS_NAMES.AM_ASSET_TYPES, true],
+        [getSpaceProcessName('space-1'), true],
+        [getSpaceProcessName('space-2'), true],
+      ]);
     });
 
-    it('should mark progress as failed and re-throw when a workspace export errors', async () => {
-      (ExportWorkspace.prototype.start as sinon.SinonStub).rejects(new Error('workspace-error'));
+    it('should mark only the failing space row as failed and continue with remaining spaces', async () => {
+      const wsStub = ExportWorkspace.prototype.start as sinon.SinonStub;
+      wsStub.onFirstCall().rejects(new Error('workspace-error'));
+      wsStub.onSecondCall().resolves();
 
       const exporter = new ExportSpaces(baseOptions);
-      try {
-        await exporter.start();
-        expect.fail('should have thrown');
-      } catch (err: any) {
-        expect(err.message).to.equal('workspace-error');
-      }
+      // Per the plan, per-space failures must NOT abort the orchestrator —
+      // they're recorded on that space's row and the next space proceeds.
+      await exporter.start();
 
-      expect(fakeProgress.completeProcess.firstCall.args).to.deep.equal([AM_MAIN_PROCESS_NAME, false]);
+      expect(wsStub.callCount).to.equal(2);
+
+      const completeArgs = fakeProgress.completeProcess.getCalls().map((c) => c.args);
+      expect(completeArgs).to.deep.include([getSpaceProcessName('space-1'), false]);
+      expect(completeArgs).to.deep.include([getSpaceProcessName('space-2'), true]);
     });
 
-    it('should mark progress as failed and re-throw when shared bootstrap export errors', async () => {
+    it('should mark shared rows as failed and re-throw when shared bootstrap export errors', async () => {
       (ExportFields.prototype.start as sinon.SinonStub).rejects(new Error('shared-bootstrap-error'));
 
       const exporter = new ExportSpaces(baseOptions);
@@ -140,7 +158,9 @@ describe('ExportSpaces', () => {
         expect(err.message).to.equal('shared-bootstrap-error');
       }
 
-      expect(fakeProgress.completeProcess.firstCall.args).to.deep.equal([AM_MAIN_PROCESS_NAME, false]);
+      const completeArgs = fakeProgress.completeProcess.getCalls().map((c) => c.args);
+      expect(completeArgs).to.deep.include([PROCESS_NAMES.AM_FIELDS, false]);
+      expect(completeArgs).to.deep.include([PROCESS_NAMES.AM_ASSET_TYPES, false]);
     });
 
     it('should use the provided parentProgressManager instead of creating a new one', async () => {
@@ -151,16 +171,20 @@ describe('ExportSpaces', () => {
         tick: sinon.stub(),
         completeProcess: sinon.stub(),
       };
-      const totalSteps = 2 + baseOptions.linkedWorkspaces.length * 4;
 
       const exporter = new ExportSpaces(baseOptions);
       exporter.setParentProgressManager(fakeParent as any);
       await exporter.start();
 
       expect((CLIProgressManager.createNested as sinon.SinonStub).callCount).to.equal(0);
-      expect(fakeParent.addProcess.firstCall.args).to.deep.equal([AM_MAIN_PROCESS_NAME, totalSteps]);
-      expect(fakeParent.startProcess.firstCall.args[0]).to.equal(AM_MAIN_PROCESS_NAME);
-      expect(fakeParent.completeProcess.firstCall.args).to.deep.equal([AM_MAIN_PROCESS_NAME, true]);
+
+      const addProcessCalls = fakeParent.addProcess.getCalls().map((c) => c.args);
+      expect(addProcessCalls).to.deep.equal([
+        [PROCESS_NAMES.AM_FIELDS, 1],
+        [PROCESS_NAMES.AM_ASSET_TYPES, 1],
+        [getSpaceProcessName('space-1'), 1],
+        [getSpaceProcessName('space-2'), 1],
+      ]);
     });
   });
 
diff --git a/packages/contentstack-asset-management/test/unit/export/workspaces.test.ts b/packages/contentstack-asset-management/test/unit/export/workspaces.test.ts
index 0a4503b04..03bdfc6bf 100644
--- a/packages/contentstack-asset-management/test/unit/export/workspaces.test.ts
+++ b/packages/contentstack-asset-management/test/unit/export/workspaces.test.ts
@@ -55,13 +55,26 @@ describe('ExportWorkspace', () => {
       expect(getSpaceStub.firstCall.args[0]).to.equal(workspace.space_uid);
     });
 
-    it('should tick success after writing metadata', async () => {
+    it('should NOT tick after writing metadata (per-space row is owned by ExportAssets)', async () => {
       sinon.stub(ExportWorkspace.prototype, 'getSpace').resolves(spaceResponse);
       const exporter = new ExportWorkspace(apiConfig, exportContext);
       await exporter.start(workspace, spaceDir, branchName);
 
+      // The per-space progress row's total is folder + metadata + downloads —
+      // all owned by ExportAssets. The workspace metadata.json write is a
+      // fixed bootstrap step and intentionally does not consume a tick.
       const tickStub = (AssetManagementExportAdapter.prototype as any).tick as sinon.SinonStub;
-      expect(tickStub.firstCall.args).to.deep.equal([true, `space: ${workspace.space_uid}`, null]);
+      expect(tickStub.callCount).to.equal(0);
+    });
+
+    it('should forward spaceProcessName to the assets exporter via setProcessName', async () => {
+      sinon.stub(ExportWorkspace.prototype, 'getSpace').resolves(spaceResponse);
+      const setProcessNameStub = sinon.stub(ExportAssets.prototype, 'setProcessName' as any);
+
+      const exporter = new ExportWorkspace(apiConfig, exportContext);
+      await exporter.start(workspace, spaceDir, branchName, 'Space space-uid-1');
+
+      expect(setProcessNameStub.firstCall.args[0]).to.equal('Space space-uid-1');
     });
 
     it('should delegate to ExportAssets.start with workspace and spaceDir', async () => {
diff --git a/packages/contentstack-asset-management/test/unit/import/spaces.test.ts b/packages/contentstack-asset-management/test/unit/import/spaces.test.ts
new file mode 100644
index 000000000..40675fadd
--- /dev/null
+++ b/packages/contentstack-asset-management/test/unit/import/spaces.test.ts
@@ -0,0 +1,151 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { CLIProgressManager, configHandler } from '@contentstack/cli-utilities';
+
+import { ImportSpaces } from '../../../src/import/spaces';
+import ImportWorkspace from '../../../src/import/workspaces';
+import ImportFields from '../../../src/import/fields';
+import ImportAssetTypes from '../../../src/import/asset-types';
+import { AssetManagementAdapter } from '../../../src/utils/asset-management-api-adapter';
+import { AssetManagementImportAdapter } from '../../../src/import/base';
+import { PROCESS_NAMES } from '../../../src/constants/index';
+
+import type { ImportSpacesOptions } from '../../../src/types/asset-management-api';
+
+describe('ImportSpaces', () => {
+  const baseOptions: ImportSpacesOptions = {
+    contentDir: '/tmp/import',
+    assetManagementUrl: 'https://am.example.com',
+    org_uid: 'org-1',
+    apiKey: 'api-key-1',
+    host: 'https://api.contentstack.io/v3',
+  };
+
+  const fakeProgress = {
+    addProcess: sinon.stub().returnsThis(),
+    startProcess: sinon.stub().returnsThis(),
+    updateStatus: sinon.stub().returnsThis(),
+    tick: sinon.stub(),
+    completeProcess: sinon.stub(),
+  };
+
+  beforeEach(() => {
+    sinon.stub(configHandler, 'get').returns({ showConsoleLogs: false });
+    sinon.stub(CLIProgressManager, 'createNested').returns(fakeProgress as any);
+    // init and listSpaces live on AssetManagementAdapter (the common base).
+    // Stubbing the base once covers both the adapter used for listSpaces and ImportWorkspace.
+    sinon.stub(AssetManagementAdapter.prototype, 'init' as any).resolves();
+    sinon.stub(AssetManagementAdapter.prototype, 'listSpaces' as any).resolves({ spaces: [] });
+    sinon.stub(ImportFields.prototype, 'start').resolves();
+    sinon.stub(ImportFields.prototype, 'setParentProgressManager');
+    sinon.stub(ImportAssetTypes.prototype, 'start').resolves();
+    sinon.stub(ImportAssetTypes.prototype, 'setParentProgressManager');
+    sinon.stub(ImportWorkspace.prototype, 'setParentProgressManager');
+
+    fakeProgress.addProcess.resetHistory();
+    fakeProgress.addProcess.returnsThis();
+    fakeProgress.startProcess.resetHistory();
+    fakeProgress.startProcess.returnsThis();
+    fakeProgress.completeProcess.reset();
+    fakeProgress.tick.reset();
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  const stubSpaceDirs = (dirs: string[]) => {
+    const fsMock = require('node:fs');
+    sinon.stub(fsMock, 'readdirSync').returns(dirs as any);
+    sinon.stub(fsMock, 'statSync').returns({ isDirectory: () => true } as any);
+  };
+
+  describe('targetDefaultSpaceUid threading', () => {
+    it('should pass targetDefaultSpaceUid and targetDefaultWorkspaceUid to ImportWorkspace.start()', async () => {
+      stubSpaceDirs(['am-space-1']);
+      const startStub = sinon
+        .stub(ImportWorkspace.prototype, 'start')
+        .resolves({ oldSpaceUid: 'am-space-1', newSpaceUid: 'target-space-3', workspaceUid: 'ws-3', isDefault: true, uidMap: {}, urlMap: {} });
+
+      const options: ImportSpacesOptions = {
+        ...baseOptions,
+        targetDefaultSpaceUid: 'target-space-3',
+        targetDefaultWorkspaceUid: 'ws-3',
+      };
+      const importer = new ImportSpaces(options);
+      await importer.start();
+
+      expect(startStub.callCount).to.equal(1);
+      const args = startStub.firstCall.args;
+      expect(args[4]).to.equal('target-space-3');
+      expect(args[5]).to.equal('ws-3');
+    });
+
+    it('should pass undefined to ImportWorkspace when targetDefaultSpaceUid is not set', async () => {
+      stubSpaceDirs(['am-space-1']);
+      const startStub = sinon
+        .stub(ImportWorkspace.prototype, 'start')
+        .resolves({ oldSpaceUid: 'am-space-1', newSpaceUid: 'new-space', workspaceUid: 'main', isDefault: false, uidMap: {}, urlMap: {} });
+
+      const importer = new ImportSpaces(baseOptions);
+      await importer.start();
+
+      expect(startStub.callCount).to.equal(1);
+      expect(startStub.firstCall.args[4]).to.be.undefined;
+      expect(startStub.firstCall.args[5]).to.be.undefined;
+    });
+
+    it('should record the correct spaceUidMap entry when default space is remapped', async () => {
+      stubSpaceDirs(['am-space-1']);
+      sinon
+        .stub(ImportWorkspace.prototype, 'start')
+        .resolves({ oldSpaceUid: 'am-space-1', newSpaceUid: 'target-space-3', workspaceUid: 'ws-3', isDefault: true, uidMap: {}, urlMap: {} });
+
+      const options: ImportSpacesOptions = {
+        ...baseOptions,
+        targetDefaultSpaceUid: 'target-space-3',
+      };
+      const importer = new ImportSpaces(options);
+      const result = await importer.start();
+
+      expect(result.spaceUidMap['am-space-1']).to.equal('target-space-3');
+      expect(result.spaceMappings[0].newSpaceUid).to.equal('target-space-3');
+      expect(result.spaceMappings[0].isDefault).to.equal(true);
+    });
+
+    it('should process non-default spaces normally alongside the remapped default space', async () => {
+      stubSpaceDirs(['am-space-1', 'am-space-2']);
+      const startStub = sinon.stub(ImportWorkspace.prototype, 'start');
+      startStub.onFirstCall().resolves({
+        oldSpaceUid: 'am-space-1', newSpaceUid: 'target-space-3', workspaceUid: 'ws-3', isDefault: true, uidMap: {}, urlMap: {},
+      });
+      startStub.onSecondCall().resolves({
+        oldSpaceUid: 'am-space-2', newSpaceUid: 'brand-new-space', workspaceUid: 'main', isDefault: false, uidMap: {}, urlMap: {},
+      });
+
+      const options: ImportSpacesOptions = {
+        ...baseOptions,
+        targetDefaultSpaceUid: 'target-space-3',
+        targetDefaultWorkspaceUid: 'ws-3',
+      };
+      const importer = new ImportSpaces(options);
+      const result = await importer.start();
+
+      expect(result.spaceMappings).to.have.lengthOf(2);
+      expect(result.spaceUidMap['am-space-1']).to.equal('target-space-3');
+      expect(result.spaceUidMap['am-space-2']).to.equal('brand-new-space');
+    });
+  });
+
+  describe('no spaces scenario', () => {
+    it('should return empty maps when spaces directory has no am* dirs', async () => {
+      stubSpaceDirs([]);
+
+      const importer = new ImportSpaces(baseOptions);
+      const result = await importer.start();
+
+      expect(result.spaceMappings).to.deep.equal([]);
+      expect(result.spaceUidMap).to.deep.equal({});
+    });
+  });
+});
diff --git a/packages/contentstack-asset-management/test/unit/import/workspaces.test.ts b/packages/contentstack-asset-management/test/unit/import/workspaces.test.ts
new file mode 100644
index 000000000..4bc87501c
--- /dev/null
+++ b/packages/contentstack-asset-management/test/unit/import/workspaces.test.ts
@@ -0,0 +1,154 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+
+import ImportWorkspace from '../../../src/import/workspaces';
+import ImportAssets from '../../../src/import/assets';
+import { AssetManagementImportAdapter } from '../../../src/import/base';
+
+import type { AssetManagementAPIConfig, ImportContext } from '../../../src/types/asset-management-api';
+
+describe('ImportWorkspace', () => {
+  const apiConfig: AssetManagementAPIConfig = {
+    baseURL: 'https://am.example.com',
+    headers: { organization_uid: 'org-1' },
+  };
+
+  const importContext: ImportContext = {
+    spacesRootPath: '/tmp/import/spaces',
+    apiKey: 'api-key-1',
+    host: 'https://api.contentstack.io/v3',
+    org_uid: 'org-1',
+  };
+
+  const spaceDir = '/tmp/import/spaces/am-space-1';
+
+  const stubMetadata = (metadata: Record<string, unknown>) => {
+    const fs = require('node:fs');
+    sinon.stub(fs, 'readFileSync').returns(JSON.stringify(metadata));
+  };
+
+  beforeEach(() => {
+    sinon.stub(AssetManagementImportAdapter.prototype, 'init' as any).resolves();
+    sinon.stub(AssetManagementImportAdapter.prototype, 'tick' as any);
+    sinon.stub(ImportAssets.prototype, 'setParentProgressManager');
+    sinon.stub(ImportAssets.prototype, 'setProcessName' as any);
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  describe('default-space mapping path', () => {
+    it('should use targetDefaultSpaceUid and skip createSpace when isDefault=true', async () => {
+      stubMetadata({ title: 'Source Default Space', is_default: true });
+      const createSpaceStub = sinon.stub(AssetManagementImportAdapter.prototype, 'createSpace' as any);
+      const assetsStartStub = sinon.stub(ImportAssets.prototype, 'start').resolves({ uidMap: {}, urlMap: {} });
+
+      const importer = new ImportWorkspace(apiConfig, importContext);
+      const result = await importer.start(
+        'am-space-1',
+        spaceDir,
+        new Set(),
+        undefined,
+        'target-default-space-uid',
+        'target-ws-uid',
+      );
+
+      expect(createSpaceStub.callCount).to.equal(0);
+      expect(assetsStartStub.callCount).to.equal(1);
+      expect(assetsStartStub.firstCall.args[0]).to.equal('target-default-space-uid');
+      expect(result.newSpaceUid).to.equal('target-default-space-uid');
+      expect(result.workspaceUid).to.equal('target-ws-uid');
+      expect(result.isDefault).to.equal(true);
+      expect(result.oldSpaceUid).to.equal('am-space-1');
+    });
+
+    it('should upload assets into the existing target default space (not identity-map)', async () => {
+      stubMetadata({ title: 'Source Default Space', is_default: true });
+      sinon.stub(AssetManagementImportAdapter.prototype, 'createSpace' as any);
+      const assetsStartStub = sinon.stub(ImportAssets.prototype, 'start').resolves({
+        uidMap: { 'old-asset-1': 'new-asset-1' },
+        urlMap: { 'old-url-1': 'new-url-1' },
+      });
+
+      const importer = new ImportWorkspace(apiConfig, importContext);
+      const result = await importer.start('am-space-1', spaceDir, new Set(), undefined, 'target-space-3');
+
+      expect(assetsStartStub.firstCall.args[0]).to.equal('target-space-3');
+      expect(result.uidMap).to.deep.equal({ 'old-asset-1': 'new-asset-1' });
+      expect(result.urlMap).to.deep.equal({ 'old-url-1': 'new-url-1' });
+    });
+
+    it('should fall back to "main" as workspaceUid when targetDefaultWorkspaceUid is not provided', async () => {
+      stubMetadata({ is_default: true });
+      sinon.stub(AssetManagementImportAdapter.prototype, 'createSpace' as any);
+      sinon.stub(ImportAssets.prototype, 'start').resolves({ uidMap: {}, urlMap: {} });
+
+      const importer = new ImportWorkspace(apiConfig, importContext);
+      const result = await importer.start('am-space-1', spaceDir, new Set(), undefined, 'target-space-3');
+
+      expect(result.workspaceUid).to.equal('main');
+    });
+
+    it('should NOT use the default-space path when isDefault=false even if targetDefaultSpaceUid is set', async () => {
+      stubMetadata({ title: 'Non-default Space', is_default: false });
+      const createSpaceStub = sinon
+        .stub(AssetManagementImportAdapter.prototype, 'createSpace' as any)
+        .resolves({ space: { uid: 'new-space-uid' } });
+      sinon.stub(ImportAssets.prototype, 'start').resolves({ uidMap: {}, urlMap: {} });
+
+      const importer = new ImportWorkspace(apiConfig, importContext);
+      const result = await importer.start('am-space-2', spaceDir, new Set(), undefined, 'target-space-3');
+
+      expect(createSpaceStub.callCount).to.equal(1);
+      expect(result.newSpaceUid).to.equal('new-space-uid');
+    });
+
+    it('should NOT use the default-space path when targetDefaultSpaceUid is undefined', async () => {
+      stubMetadata({ title: 'Source Default Space', is_default: true });
+      const createSpaceStub = sinon
+        .stub(AssetManagementImportAdapter.prototype, 'createSpace' as any)
+        .resolves({ space: { uid: 'brand-new-uid' } });
+      sinon.stub(ImportAssets.prototype, 'start').resolves({ uidMap: {}, urlMap: {} });
+
+      const importer = new ImportWorkspace(apiConfig, importContext);
+      const result = await importer.start('am-space-1', spaceDir, new Set());
+
+      expect(createSpaceStub.callCount).to.equal(1);
+      expect(result.newSpaceUid).to.equal('brand-new-uid');
+    });
+  });
+
+  describe('identity-reuse path (existing uid match)', () => {
+    it('should reuse existing space uid and call buildIdentityMappersFromExport', async () => {
+      stubMetadata({ title: 'Space', is_default: false });
+      const identityStub = sinon
+        .stub(ImportAssets.prototype, 'buildIdentityMappersFromExport')
+        .resolves({ uidMap: { a: 'a' }, urlMap: {} });
+      sinon.stub(AssetManagementImportAdapter.prototype, 'createSpace' as any);
+
+      const importer = new ImportWorkspace(apiConfig, importContext);
+      const result = await importer.start('am-space-existing', spaceDir, new Set(['am-space-existing']));
+
+      expect(identityStub.callCount).to.equal(1);
+      expect(result.newSpaceUid).to.equal('am-space-existing');
+    });
+  });
+
+  describe('create new space path', () => {
+    it('should create a new space and upload assets for non-default non-existing space', async () => {
+      stubMetadata({ title: 'Source Space 2', is_default: false });
+      const createStub = sinon
+        .stub(AssetManagementImportAdapter.prototype, 'createSpace' as any)
+        .resolves({ space: { uid: 'new-space-2-uid' } });
+      sinon.stub(ImportAssets.prototype, 'start').resolves({ uidMap: {}, urlMap: {} });
+
+      const importer = new ImportWorkspace(apiConfig, importContext);
+      const result = await importer.start('am-space-2', spaceDir, new Set());
+
+      expect(createStub.callCount).to.equal(1);
+      expect(result.newSpaceUid).to.equal('new-space-2-uid');
+      expect(result.isDefault).to.equal(false);
+    });
+  });
+});
diff --git a/packages/contentstack-audit/README.md b/packages/contentstack-audit/README.md
index 116024c10..81eb8c8fe 100644
--- a/packages/contentstack-audit/README.md
+++ b/packages/contentstack-audit/README.md
@@ -19,7 +19,7 @@ $ npm install -g @contentstack/cli-audit
 $ csdx COMMAND
 running command...
 $ csdx (--version|-v)
-@contentstack/cli-audit/2.0.0-beta.10 darwin-arm64 node-v22.13.1
+@contentstack/cli-audit/2.0.0-beta.11 darwin-arm64 node-v22.13.1
 $ csdx --help [COMMAND]
 USAGE
   $ csdx COMMAND
@@ -32,7 +32,6 @@ USAGE
 <!-- commands -->
 * [`csdx cm:stacks:audit`](#csdx-cmstacksaudit)
 * [`csdx cm:stacks:audit:fix`](#csdx-cmstacksauditfix)
-* [`csdx help [COMMAND]`](#csdx-help-command)
 
 ## `csdx cm:stacks:audit`
 
@@ -157,5 +156,5 @@ DESCRIPTION
   Display help for csdx.
 ```
 
-_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/6.2.44/src/commands/help.ts)_
+_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v6.2.37/src/commands/help.ts)_
 <!-- commandsstop -->
diff --git a/packages/contentstack-audit/package.json b/packages/contentstack-audit/package.json
index 746203cfc..0cec053f2 100644
--- a/packages/contentstack-audit/package.json
+++ b/packages/contentstack-audit/package.json
@@ -21,12 +21,10 @@
     "@contentstack/cli-command": "~2.0.0-beta.6",
     "@contentstack/cli-utilities": "~2.0.0-beta.7",
     "@oclif/core": "^4.3.0",
-    "@oclif/plugin-help": "^6.2.28",
     "chalk": "^5.6.2",
     "fast-csv": "^4.3.6",
     "fs-extra": "^11.3.0",
     "lodash": "^4.18.1",
-    "uuid": "^9.0.1",
     "winston": "^3.19.0"
   },
   "devDependencies": {
@@ -35,9 +33,8 @@
     "@types/fs-extra": "^11.0.4",
     "@types/mocha": "^10.0.10",
     "@types/node": "^20.17.50",
-    "@types/uuid": "^9.0.8",
     "chai": "^4.5.0",
-    "eslint": "^8.57.1",
+    "eslint": "^9.26.0",
     "eslint-config-oclif": "^6.0.62",
     "eslint-config-oclif-typescript": "^3.1.14",
     "mocha": "^10.8.2",
@@ -51,9 +48,6 @@
   "oclif": {
     "bin": "csdx",
     "commands": "./lib/commands",
-    "plugins": [
-      "@oclif/plugin-help"
-    ],
     "topicSeparator": ":",
     "additionalHelpFlags": [
       "-h"
diff --git a/packages/contentstack-audit/src/audit-base-command.ts b/packages/contentstack-audit/src/audit-base-command.ts
index afc5f632c..33cf6c740 100644
--- a/packages/contentstack-audit/src/audit-base-command.ts
+++ b/packages/contentstack-audit/src/audit-base-command.ts
@@ -1,7 +1,6 @@
 import { getChalk } from '@contentstack/cli-utilities';
 import * as csv from 'fast-csv';
 import { copy } from 'fs-extra';
-import { v4 as uuid } from 'uuid';
 import isEmpty from 'lodash/isEmpty';
 import { join, resolve } from 'path';
 import cloneDeep from 'lodash/cloneDeep';
@@ -15,6 +14,7 @@ import {
   CLIProgressManager,
   clearProgressModuleSetting,
   readContentTypeSchemas,
+  generateUid
 } from '@contentstack/cli-utilities';
 import { createWriteStream, existsSync, mkdirSync, readFileSync, writeFileSync, rmSync } from 'fs';
 import config from './config';
@@ -471,7 +471,7 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
         this.flags['copy-path'] ||
         this.flags['data-dir'] ||
         this.sharedConfig.basePath
-      ).replace(/\/+$/, '')}_backup_${uuid()}`;
+      ).replace(/\/+$/, '')}_backup_${generateUid()}`;
 
       if (!existsSync(backupDirPath)) {
         mkdirSync(backupDirPath, { recursive: true });
diff --git a/packages/contentstack-audit/src/modules/assets.ts b/packages/contentstack-audit/src/modules/assets.ts
index c6c1a637b..39c357b96 100644
--- a/packages/contentstack-audit/src/modules/assets.ts
+++ b/packages/contentstack-audit/src/modules/assets.ts
@@ -8,6 +8,20 @@ import values from 'lodash/values';
 import { keys } from 'lodash';
 import BaseClass from './base-class';
 
+/**
+ * Multibar row label for a single space. Bounded to 14 chars after the
+ * `Space ` prefix so CLIProgressManager.formatProcessName doesn't truncate the
+ * row mid-string. Mirrors the helper in `@contentstack/cli-asset-management`.
+ */
+const SPACE_PROCESS_NAME_PREFIX = 'Space ';
+const SPACE_PROCESS_NAME_MAX_UID_LEN = 14;
+function getSpaceProcessName(spaceUid: string): string {
+  const safe = spaceUid ?? '';
+  const trimmed =
+    safe.length > SPACE_PROCESS_NAME_MAX_UID_LEN ? safe.substring(0, SPACE_PROCESS_NAME_MAX_UID_LEN) : safe;
+  return `${SPACE_PROCESS_NAME_PREFIX}${trimmed}`;
+}
+
 /* The `Assets` class is responsible for scanning assets, looking for missing environment/locale references,
 and generating a report in JSON and CSV formats. */
 export default class Assets extends BaseClass {
@@ -24,6 +38,8 @@ export default class Assets extends BaseClass {
   public moduleName: keyof typeof auditConfig.moduleConfig;
   private fixOverwriteConfirmed: boolean | null = null;
   private resolvedBasePaths: Array<{ path: string; spaceId: string | null }> = [];
+  /** Map space dir name → the per-space multibar row label, or empty when single-space. */
+  private spaceProcessNames: Map<string, string> = new Map();
 
   constructor({ fix, config, moduleName }: ModuleConstructorParam & CtConstructorParam) {
     super({ config });
@@ -71,15 +87,32 @@ export default class Assets extends BaseClass {
         await this.prerequisiteData();
       });
 
-      // Create progress manager if we have a total count
-      if (totalCount && totalCount > 0) {
+      // Resolve base paths up front so the progress UI can decide between a
+      // simple single-bar layout (legacy export) and a per-space multibar.
+      this.resolvedBasePaths = this.resolveAssetBasePaths();
+      log.debug(`Resolved ${this.resolvedBasePaths.length} asset base path(s)`, this.config.auditContext);
+
+      const isMultiSpace =
+        this.resolvedBasePaths.length > 1 ||
+        (this.resolvedBasePaths.length === 1 && this.resolvedBasePaths[0].spaceId !== null);
+
+      if (isMultiSpace) {
+        const progress = this.createNestedProgress(this.moduleName);
+        for (const { path, spaceId } of this.resolvedBasePaths) {
+          // Each space row's total = number of assets in that space; pre-counted
+          // from the chunked metadata so the bar shows real progress as ticks
+          // accumulate inside lookForReference.
+          const rowName = getSpaceProcessName(spaceId ?? 'unknown');
+          this.spaceProcessNames.set(spaceId ?? path, rowName);
+          const spaceTotal = this.countAssetsInChunkedStore(path);
+          progress.addProcess(rowName, Math.max(1, spaceTotal));
+        }
+      } else if (totalCount && totalCount > 0) {
+        // Legacy flat layout — single progress bar for the whole asset set.
         const progress = this.createSimpleProgress(this.moduleName, totalCount);
         progress.updateStatus('Validating asset references...');
       }
 
-      this.resolvedBasePaths = this.resolveAssetBasePaths();
-      log.debug(`Resolved ${this.resolvedBasePaths.length} asset base path(s)`, this.config.auditContext);
-
       log.debug('Starting asset Reference, Environment and Locale validation', this.config.auditContext);
       await this.lookForReference();
 
@@ -250,8 +283,16 @@ export default class Assets extends BaseClass {
         cliux.print($t(auditMsg.AUDITING_SPACE, { spaceId }), { color: 'cyan' });
       }
 
-      // Progress bar UX: update status label to reflect the current space
-      this.progressManager?.updateStatus?.(spaceId ? `Space: ${spaceId}` : 'Scanning assets...');
+      // Multi-space layout: start the per-space row and route ticks below to it.
+      // Single-space (legacy) layout falls back to the existing simple progress
+      // bar with a status update.
+      const spaceProcessName = this.spaceProcessNames.get(spaceId ?? spacePath);
+      if (spaceProcessName) {
+        this.progressManager?.startProcess?.(spaceProcessName);
+        this.progressManager?.updateStatus?.(`Space: ${spaceId ?? 'assets'}`, spaceProcessName);
+      } else {
+        this.progressManager?.updateStatus?.(spaceId ? `Space: ${spaceId}` : 'Scanning assets...');
+      }
 
       let fsUtility = new FsUtility({ basePath: spacePath, indexFileName: 'assets.json' });
       let indexer = fsUtility.indexFileContent;
@@ -332,7 +373,9 @@ export default class Assets extends BaseClass {
           );
 
           if (this.progressManager) {
-            this.progressManager.tick(true, `asset: ${assetUid}`, null);
+            // Route the tick to the per-space row when multi-space, otherwise
+            // tick the single legacy progress bar (processName arg defaults).
+            this.progressManager.tick(true, `asset: ${assetUid}`, null, spaceProcessName);
           }
 
           if (this.fix) {
@@ -345,6 +388,12 @@ export default class Assets extends BaseClass {
           await this.writeFixContent(`${spacePath}/${indexer[fileIndex]}`, this.assets);
         }
       }
+
+      // Per-space row finished — close it so the multibar shows ✓ Complete
+      // and the next space (if any) starts cleanly.
+      if (spaceProcessName) {
+        this.progressManager?.completeProcess?.(spaceProcessName, true);
+      }
     }
 
     log.debug(
@@ -354,4 +403,30 @@ export default class Assets extends BaseClass {
       this.config.auditContext,
     );
   }
+
+  /**
+   * Sum the asset count across all chunk metadata files for a given space's
+   * `assets/` directory. Used by `run` to seed each per-space progress row's
+   * total before validation begins. Falls back to walking chunk files if the
+   * aggregated `metadata.json` is unavailable (older exports).
+   */
+  private countAssetsInChunkedStore(assetsDir: string): number {
+    try {
+      const fsUtility = new FsUtility({ basePath: assetsDir, indexFileName: 'assets.json' });
+      const meta = fsUtility.getPlainMeta();
+      let total = 0;
+      for (const value of Object.values(meta)) {
+        if (Array.isArray(value)) total += value.length;
+      }
+      if (total > 0) return total;
+
+      // Fallback: count keys across each chunk file (slow path for legacy
+      // exports without metadata.json).
+      const indexer = fsUtility.indexFileContent ?? {};
+      return Object.keys(indexer).length;
+    } catch (e) {
+      log.debug(`Could not pre-count assets in ${assetsDir}: ${e}`, this.config.auditContext);
+      return 0;
+    }
+  }
 }
diff --git a/packages/contentstack-bootstrap/README.md b/packages/contentstack-bootstrap/README.md
index 90ec69628..38991eec0 100644
--- a/packages/contentstack-bootstrap/README.md
+++ b/packages/contentstack-bootstrap/README.md
@@ -15,7 +15,7 @@ $ npm install -g @contentstack/cli-cm-bootstrap
 $ csdx COMMAND
 running command...
 $ csdx (--version)
-@contentstack/cli-cm-bootstrap/2.0.0-beta.11 darwin-arm64 node-v24.13.0
+@contentstack/cli-cm-bootstrap/2.0.0-beta.16 darwin-arm64 node-v22.13.1
 $ csdx --help [COMMAND]
 USAGE
   $ csdx COMMAND
diff --git a/packages/contentstack-bootstrap/package.json b/packages/contentstack-bootstrap/package.json
index 0e0409213..f3ec9d914 100644
--- a/packages/contentstack-bootstrap/package.json
+++ b/packages/contentstack-bootstrap/package.json
@@ -21,9 +21,8 @@
     "@contentstack/cli-utilities": "~2.0.0-beta.7",
     "@contentstack/cli-config": "~2.0.0-beta.8",
     "@oclif/core": "^4.3.0",
-    "@oclif/plugin-help": "^6.2.37",
     "inquirer": "12.11.1",
-    "mkdirp": "^1.0.4",
+    "mkdirp": "^2.1.6",
     "tar": "^7.5.11"
   },
   "devDependencies": {
@@ -33,9 +32,7 @@
     "@types/node": "^18.11.9",
     "@types/tar": "^6.1.13",
     "chai": "^4.5.0",
-    "eslint": "^8.57.1",
-    "eslint-config-oclif": "^6.0.62",
-    "eslint-config-oclif-typescript": "^3.1.14",
+    "eslint": "^9.26.0",
     "mocha": "10.8.2",
     "nyc": "^15.1.0",
     "oclif": "^4.17.46",
@@ -73,4 +70,4 @@
     }
   },
   "repository": "contentstack/cli"
-}
+}
\ No newline at end of file
diff --git a/packages/contentstack-branches/README.md b/packages/contentstack-branches/README.md
index 2b6cb6e51..5fcb24e51 100755
--- a/packages/contentstack-branches/README.md
+++ b/packages/contentstack-branches/README.md
@@ -37,7 +37,7 @@ $ npm install -g @contentstack/cli-cm-branches
 $ csdx COMMAND
 running command...
 $ csdx (--version)
-@contentstack/cli-cm-branches/2.0.0-beta.2 darwin-arm64 node-v24.13.0
+@contentstack/cli-cm-branches/2.0.0-beta.6 darwin-arm64 node-v22.13.1
 $ csdx --help [COMMAND]
 USAGE
   $ csdx COMMAND
@@ -53,7 +53,6 @@ USAGE
 * [`csdx cm:branches:delete [-uid <value>] [-k <value>]`](#csdx-cmbranchesdelete--uid-value--k-value)
 * [`csdx cm:branches:diff [--base-branch <value>] [--compare-branch <value>] [-k <value>][--module <value>] [--format <value>] [--csv-path <value>]`](#csdx-cmbranchesdiff---base-branch-value---compare-branch-value--k-value--module-value---format-value---csv-path-value)
 * [`csdx cm:branches:merge [-k <value>][--compare-branch <value>] [--no-revert] [--export-summary-path <value>] [--use-merge-summary <value>] [--comment <value>] [--base-branch <value>]`](#csdx-cmbranchesmerge--k-value--compare-branch-value---no-revert---export-summary-path-value---use-merge-summary-value---comment-value---base-branch-value)
-* [`csdx cm:branches:merge-status -k <value> --merge-uid <value>`](#csdx-cmbranchesmerge-status--k-value---merge-uid-value)
 
 ## `csdx cm:branches`
 
@@ -231,27 +230,4 @@ EXAMPLES
 ```
 
 _See code: [src/commands/cm/branches/merge.ts](https://github.com/contentstack/cli/blob/main/packages/contentstack-export/src/commands/cm/branches/merge.ts)_
-
-## `csdx cm:branches:merge-status -k <value> --merge-uid <value>`
-
-Check the status of a branch merge job
-
-```
-USAGE
-  $ csdx cm:branches:merge-status -k <value> --merge-uid <value>
-
-FLAGS
-  -k, --stack-api-key=<value>  (required) Provide your stack API key.
-      --merge-uid=<value>      (required) Merge job UID to check status for.
-
-DESCRIPTION
-  Check the status of a branch merge job
-
-EXAMPLES
-  $ csdx cm:branches:merge-status -k bltxxxxxxxx --merge-uid merge_abc123
-
-  $ csdx cm:branches:merge-status --stack-api-key bltxxxxxxxx --merge-uid merge_abc123
-```
-
-_See code: [src/commands/cm/branches/merge-status.ts](https://github.com/contentstack/cli/blob/main/packages/contentstack-export/src/commands/cm/branches/merge-status.ts)_
 <!-- commandsstop -->
diff --git a/packages/contentstack-branches/package.json b/packages/contentstack-branches/package.json
index f88b604f9..8ba194ad8 100644
--- a/packages/contentstack-branches/package.json
+++ b/packages/contentstack-branches/package.json
@@ -7,20 +7,16 @@
   "dependencies": {
     "@contentstack/cli-command": "~2.0.0-beta.6",
     "@oclif/core": "^4.3.0",
-    "@oclif/plugin-help": "^6.2.28",
     "@contentstack/cli-utilities": "~2.0.0-beta.7",
     "chalk": "^5.6.2",
     "just-diff": "^6.0.2",
     "lodash": "^4.18.1"
   },
   "devDependencies": {
-    "@contentstack/cli-dev-dependencies": "~2.0.0-beta.0",
-    "@oclif/plugin-help": "^6.2.28",
-    "@types/flat": "^5.0.5",
     "chai": "^4.5.0",
     "dotenv": "^16.5.0",
     "dotenv-expand": "^9.0.0",
-    "eslint": "^8.57.1",
+    "eslint": "^9.26.0",
     "eslint-config-oclif": "^6.0.62",
     "mocha": "10.8.2",
     "nyc": "^15.1.0",
@@ -80,4 +76,4 @@
     }
   },
   "repository": "https://github.com/contentstack/cli"
-}
\ No newline at end of file
+}
diff --git a/packages/contentstack-clone/README.md b/packages/contentstack-clone/README.md
index 4c818981a..f67e967e7 100644
--- a/packages/contentstack-clone/README.md
+++ b/packages/contentstack-clone/README.md
@@ -16,7 +16,7 @@ $ npm install -g @contentstack/cli-cm-clone
 $ csdx COMMAND
 running command...
 $ csdx (--version)
-@contentstack/cli-cm-clone/2.0.0-beta.17 darwin-arm64 node-v22.13.1
+@contentstack/cli-cm-clone/2.0.0-beta.12 darwin-arm64 node-v24.13.0
 $ csdx --help [COMMAND]
 USAGE
   $ csdx COMMAND
diff --git a/packages/contentstack-clone/package.json b/packages/contentstack-clone/package.json
index 7604b5871..aadcbc8b2 100644
--- a/packages/contentstack-clone/package.json
+++ b/packages/contentstack-clone/package.json
@@ -11,7 +11,6 @@
     "@contentstack/cli-command": "~2.0.0-beta.6",
     "@contentstack/cli-utilities": "~2.0.0-beta.7",
     "@oclif/core": "^4.3.0",
-    "@oclif/plugin-help": "^6.2.28",
     "chalk": "^5.6.2",
     "inquirer": "12.11.1",
     "lodash": "^4.18.1",
@@ -28,7 +27,7 @@
     "@types/sinon": "^10.0.0",
     "@typescript-eslint/eslint-plugin": "^5.62.0",
     "chai": "^4.5.0",
-    "eslint": "^8.57.1",
+    "eslint": "^9.26.0",
     "eslint-config-oclif": "^6.0.62",
     "mocha": "^10.8.2",
     "nyc": "^15.1.0",
@@ -78,4 +77,4 @@
       "cm:stacks:clone": "CLN"
     }
   }
-}
+}
\ No newline at end of file
diff --git a/packages/contentstack-export-to-csv/package.json b/packages/contentstack-export-to-csv/package.json
index 4ad451a09..ffdae47cf 100644
--- a/packages/contentstack-export-to-csv/package.json
+++ b/packages/contentstack-export-to-csv/package.json
@@ -8,7 +8,6 @@
     "@contentstack/cli-command": "~2.0.0-beta.6",
     "@contentstack/cli-utilities": "~2.0.0-beta.7",
     "@oclif/core": "^4.8.0",
-    "@oclif/plugin-help": "^6.2.32",
     "fast-csv": "^4.3.6"
   },
   "devDependencies": {
@@ -18,11 +17,10 @@
     "@types/mocha": "^10.0.10",
     "@types/node": "^20.17.50",
     "chai": "^4.5.0",
-    "eslint": "^8.57.1",
+    "eslint": "^9.26.0",
     "eslint-config-oclif": "^6.0.62",
     "eslint-config-oclif-typescript": "^3.1.14",
     "mocha": "^10.8.2",
-    "nock": "^13.5.6",
     "nyc": "^15.1.0",
     "oclif": "^4.17.46",
     "sinon": "^21.0.1",
@@ -73,4 +71,4 @@
     "test:unit:report": "nyc --extension .ts mocha --forbid-only \"test/unit/**/*.test.ts\"",
     "version": "oclif readme && git add README.md"
   }
-}
\ No newline at end of file
+}
diff --git a/packages/contentstack-export/README.md b/packages/contentstack-export/README.md
index 56e4bcdd3..fa4e85160 100755
--- a/packages/contentstack-export/README.md
+++ b/packages/contentstack-export/README.md
@@ -48,7 +48,7 @@ $ npm install -g @contentstack/cli-cm-export
 $ csdx COMMAND
 running command...
 $ csdx (--version)
-@contentstack/cli-cm-export/2.0.0-beta.11 darwin-arm64 node-v24.13.0
+@contentstack/cli-cm-export/2.0.0-beta.16 darwin-arm64 node-v22.13.1
 $ csdx --help [COMMAND]
 USAGE
   $ csdx COMMAND
diff --git a/packages/contentstack-export/package.json b/packages/contentstack-export/package.json
index 6006ab2fc..1e94d41a5 100644
--- a/packages/contentstack-export/package.json
+++ b/packages/contentstack-export/package.json
@@ -36,8 +36,7 @@
     "chai": "^4.4.1",
     "dotenv": "^16.5.0",
     "dotenv-expand": "^9.0.0",
-    "eslint": "^8.57.1",
-    "eslint-config-oclif": "^6.0.68",
+    "eslint": "^9.26.0",
     "mocha": "10.8.2",
     "nyc": "^15.1.0",
     "oclif": "^4.17.46",
@@ -95,4 +94,4 @@
     }
   },
   "repository": "https://github.com/contentstack/cli"
-}
+}
\ No newline at end of file
diff --git a/packages/contentstack-export/src/commands/cm/stacks/export.ts b/packages/contentstack-export/src/commands/cm/stacks/export.ts
index af89dec6c..97f596f7f 100644
--- a/packages/contentstack-export/src/commands/cm/stacks/export.ts
+++ b/packages/contentstack-export/src/commands/cm/stacks/export.ts
@@ -14,6 +14,7 @@ import {
   getSessionLogPath,
   CLIProgressManager,
   clearProgressModuleSetting,
+  loadChalk,
 } from '@contentstack/cli-utilities';
 
 import { ModuleExporter } from '../../../export';
@@ -87,6 +88,7 @@ export default class ExportCommand extends Command {
   };
 
   async run(): Promise<void> {
+    await loadChalk();
     let exportDir: string = pathValidator('logs');
     try {
       const { flags } = await this.parse(ExportCommand);
@@ -103,9 +105,7 @@ export default class ExportCommand extends Command {
       const moduleExporter = new ModuleExporter(managementAPIClient, exportConfig);
       await moduleExporter.start();
       const sessionLogPath = getSessionLogPath();
-      log.success(
-        `The content of the stack ${exportConfig.apiKey} has been exported successfully!`,
-      );
+      log.success(`The content of the stack ${exportConfig.apiKey} has been exported successfully!`);
       log.info(`The exported content has been stored at '${exportDir}'`, exportConfig.context);
       log.success(`The log has been stored at '${sessionLogPath}'`, exportConfig.context);
 
diff --git a/packages/contentstack-export/src/config/index.ts b/packages/contentstack-export/src/config/index.ts
index da39dc24c..6735ab724 100644
--- a/packages/contentstack-export/src/config/index.ts
+++ b/packages/contentstack-export/src/config/index.ts
@@ -35,6 +35,7 @@ const config: DefaultConfig = {
       'content-types',
       'custom-roles',
       'workflows',
+      'publishing-rules',
       'personalize',
       'entries',
       'labels',
@@ -85,6 +86,11 @@ const config: DefaultConfig = {
       fileName: 'workflows.json',
       invalidKeys: ['stackHeaders', 'urlPath', 'created_at', 'updated_at', 'created_by', 'updated_by'],
     },
+    'publishing-rules': {
+      dirName: 'workflows',
+      fileName: 'publishing-rules.json',
+      invalidKeys: ['stackHeaders', 'urlPath', 'created_at', 'updated_at', 'created_by', 'updated_by'],
+    },
     globalfields: {
       dirName: 'global_fields',
       fileName: 'globalfields.json',
diff --git a/packages/contentstack-export/src/export/modules/publishing-rules.ts b/packages/contentstack-export/src/export/modules/publishing-rules.ts
new file mode 100644
index 000000000..483189994
--- /dev/null
+++ b/packages/contentstack-export/src/export/modules/publishing-rules.ts
@@ -0,0 +1,86 @@
+import omit from 'lodash/omit';
+import isEmpty from 'lodash/isEmpty';
+import { resolve as pResolve } from 'node:path';
+import { handleAndLogError, log } from '@contentstack/cli-utilities';
+
+import BaseClass from './base-class';
+import { fsUtil } from '../../utils';
+import { PublishingRulesConfig, ModuleClassParams } from '../../types';
+
+export default class ExportPublishingRules extends BaseClass {
+  private readonly publishingRules: Record<string, Record<string, unknown>> = {};
+  private readonly publishingRulesConfig: PublishingRulesConfig;
+  private publishingRulesFolderPath: string;
+  private readonly qs: { include_count: boolean; skip?: number };
+
+  constructor({ exportConfig, stackAPIClient }: ModuleClassParams) {
+    super({ exportConfig, stackAPIClient });
+    this.publishingRulesConfig = exportConfig.modules['publishing-rules'];
+    this.qs = { include_count: true };
+    this.exportConfig.context.module = 'publishing-rules';
+  }
+
+  async start(): Promise<void> {
+    this.publishingRulesFolderPath = pResolve(
+      this.exportConfig.data,
+      this.exportConfig.branchName || '',
+      this.publishingRulesConfig.dirName,
+    );
+    log.debug(`Publishing rules folder path: ${this.publishingRulesFolderPath}`, this.exportConfig.context);
+
+    await fsUtil.makeDirectory(this.publishingRulesFolderPath);
+    log.debug('Created publishing rules directory', this.exportConfig.context);
+
+    await this.fetchAllPublishingRules();
+
+    if (isEmpty(this.publishingRules)) {
+      log.info('No Publishing Rules found', this.exportConfig.context);
+      return;
+    }
+
+    const outPath = pResolve(this.publishingRulesFolderPath, this.publishingRulesConfig.fileName);
+    fsUtil.writeFile(outPath, this.publishingRules);
+    log.success(
+      `Publishing rules exported successfully! Total count: ${Object.keys(this.publishingRules).length}`,
+      this.exportConfig.context,
+    );
+  }
+
+  private async fetchAllPublishingRules(skip = 0): Promise<void> {
+    try {
+      if (skip > 0) {
+        this.qs.skip = skip;
+      }
+
+      const data: { items?: Record<string, unknown>[]; count?: number } = await this.stack
+        .workflow()
+        .publishRule()
+        .fetchAll(this.qs);
+
+      const items = data.items ?? [];
+      const total = data.count ?? items.length;
+
+      if (!items.length) {
+        log.debug('No publishing rules returned for this page', this.exportConfig.context);
+        return;
+      }
+
+      for (const rule of items) {
+        const uid = rule.uid as string | undefined;
+        if (uid) {
+          this.publishingRules[uid] = omit(rule, this.publishingRulesConfig.invalidKeys) as Record<
+            string,
+            unknown
+          >;
+        }
+      }
+
+      const nextSkip = skip + items.length;
+      if (nextSkip < total) {
+        await this.fetchAllPublishingRules(nextSkip);
+      }
+    } catch (error: unknown) {
+      handleAndLogError(error as Error, { ...this.exportConfig.context });
+    }
+  }
+}
diff --git a/packages/contentstack-export/src/types/default-config.ts b/packages/contentstack-export/src/types/default-config.ts
index 7fedadd61..b9f933363 100644
--- a/packages/contentstack-export/src/types/default-config.ts
+++ b/packages/contentstack-export/src/types/default-config.ts
@@ -66,6 +66,13 @@ export default interface DefaultConfig {
       invalidKeys: string[];
       dependencies?: Modules[];
     };
+    'publishing-rules': {
+      dirName: string;
+      fileName: string;
+      invalidKeys: string[];
+      dependencies?: Modules[];
+      limit?: number;
+    };
     globalfields: {
       dirName: string;
       fileName: string;
diff --git a/packages/contentstack-export/src/types/index.ts b/packages/contentstack-export/src/types/index.ts
index 3f06ebdb7..f0885e75a 100644
--- a/packages/contentstack-export/src/types/index.ts
+++ b/packages/contentstack-export/src/types/index.ts
@@ -47,6 +47,7 @@ export type Modules =
   | 'content-types'
   | 'custom-roles'
   | 'workflows'
+  | 'publishing-rules'
   | 'labels'
   | 'marketplace-apps'
   | 'taxonomies'
@@ -118,6 +119,14 @@ export interface WorkflowConfig {
   limit?: number;
 }
 
+export interface PublishingRulesConfig {
+  dirName: string;
+  fileName: string;
+  invalidKeys: string[];
+  dependencies?: Modules[];
+  limit?: number;
+}
+
 export interface CustomRoleConfig {
   dirName: string;
   fileName: string;
diff --git a/packages/contentstack-export/src/utils/progress-strategy-registry.ts b/packages/contentstack-export/src/utils/progress-strategy-registry.ts
index b50c1e86b..85a2fdfe2 100644
--- a/packages/contentstack-export/src/utils/progress-strategy-registry.ts
+++ b/packages/contentstack-export/src/utils/progress-strategy-registry.ts
@@ -1,4 +1,4 @@
-import { AM_MAIN_PROCESS_NAME } from '@contentstack/cli-asset-management';
+import { AM_MAIN_PROCESS_NAME, isSpaceProcessName } from '@contentstack/cli-asset-management';
 import { MODULE_CONTEXTS, MODULE_NAMES, PROCESS_NAMES } from './constants';
 /**
  * Progress Strategy Registrations for Export Modules
@@ -13,6 +13,31 @@ import {
   DefaultProgressStrategy,
 } from '@contentstack/cli-utilities';
 
+/**
+ * Sum the totals/success/failure counts across every per-space process row in
+ * the multibar. Used by the AM 2.0 Assets strategy so the final summary reports
+ * total assets-across-all-spaces instead of the placeholder row.
+ *
+ * Returns null when no per-space rows exist, letting the strategy fall back to
+ * legacy process names.
+ */
+function aggregateSpaceProcesses(
+  processes: Map<string, { total: number; successCount: number; failureCount: number }>,
+): { total: number; success: number; failures: number } | null {
+  let total = 0;
+  let success = 0;
+  let failures = 0;
+  let found = false;
+  for (const [name, data] of processes) {
+    if (!isSpaceProcessName(name)) continue;
+    found = true;
+    total += data.total;
+    success += data.successCount;
+    failures += data.failureCount;
+  }
+  return found ? { total, success, failures } : null;
+}
+
 // Wrap all registrations in try-catch to prevent module loading errors
 try {
   ProgressStrategyRegistry.register(MODULE_NAMES[MODULE_CONTEXTS.CONTENT_TYPES], new DefaultProgressStrategy());
@@ -31,7 +56,12 @@ try {
           failures: downloadsProcess.failureCount,
         };
       }
-      // Asset Management 2.0 path (process name owned by AM package)
+      // Asset Management 2.0 (per-space layout): sum every "Space *" row so the
+      // final summary reports total assets-across-all-spaces. Falls through to
+      // the legacy AM_MAIN/SPACES rows when the per-space layout isn't in use.
+      const spaceTotals = aggregateSpaceProcesses(processes);
+      if (spaceTotals) return spaceTotals;
+
       const amProcess = processes.get(AM_MAIN_PROCESS_NAME);
       if (amProcess) {
         return {
diff --git a/packages/contentstack-export/test/unit/export/modules/assets.test.ts b/packages/contentstack-export/test/unit/export/modules/assets.test.ts
index de7dd4d75..319bc064f 100644
--- a/packages/contentstack-export/test/unit/export/modules/assets.test.ts
+++ b/packages/contentstack-export/test/unit/export/modules/assets.test.ts
@@ -112,6 +112,11 @@ describe('ExportAssets', () => {
           fileName: 'workflows.json',
           invalidKeys: [],
         },
+        'publishing-rules': {
+          dirName: 'workflows',
+          fileName: 'publishing-rules.json',
+          invalidKeys: [],
+        },
         globalfields: {
           dirName: 'global_fields',
           fileName: 'globalfields.json',
@@ -312,6 +317,7 @@ describe('ExportAssets', () => {
         return await fn();
       });
       sinon.stub(exportAssets as any, 'completeProgress');
+      getAssetsCountStub.withArgs(false).resolves(10).withArgs(true).resolves(5);
     });
 
     afterEach(() => {
diff --git a/packages/contentstack-export/test/unit/export/modules/base-class.test.ts b/packages/contentstack-export/test/unit/export/modules/base-class.test.ts
index 52eefd922..2b5b739fe 100644
--- a/packages/contentstack-export/test/unit/export/modules/base-class.test.ts
+++ b/packages/contentstack-export/test/unit/export/modules/base-class.test.ts
@@ -129,6 +129,11 @@ describe('BaseClass', () => {
           fileName: 'workflows.json',
           invalidKeys: [],
         },
+        'publishing-rules': {
+          dirName: 'workflows',
+          fileName: 'publishing-rules.json',
+          invalidKeys: [],
+        },
         globalfields: {
           dirName: 'global_fields',
           fileName: 'globalfields.json',
@@ -240,7 +245,7 @@ describe('BaseClass', () => {
           dirName: 'composable_studio',
           fileName: 'composable_studio.json',
           apiBaseUrl: 'https://api.contentstack.io',
-          apiVersion: 'v3'
+          apiVersion: 'v3',
         },
       },
     } as ExportConfig;
diff --git a/packages/contentstack-import-setup/README.md b/packages/contentstack-import-setup/README.md
index 40ed66f01..dfb7b040c 100644
--- a/packages/contentstack-import-setup/README.md
+++ b/packages/contentstack-import-setup/README.md
@@ -47,7 +47,7 @@ $ npm install -g @contentstack/cli-cm-import-setup
 $ csdx COMMAND
 running command...
 $ csdx (--version)
-@contentstack/cli-cm-import-setup/2.0.0-beta.10 darwin-arm64 node-v22.13.1
+@contentstack/cli-cm-import-setup/2.0.0-beta.6 darwin-arm64 node-v24.13.0
 $ csdx --help [COMMAND]
 USAGE
   $ csdx COMMAND
diff --git a/packages/contentstack-import-setup/package.json b/packages/contentstack-import-setup/package.json
index 1ba8ffb26..e2e2579ad 100644
--- a/packages/contentstack-import-setup/package.json
+++ b/packages/contentstack-import-setup/package.json
@@ -18,7 +18,6 @@
   },
   "devDependencies": {
     "@types/big-json": "^3.2.5",
-    "@types/bluebird": "^3.5.42",
     "@types/chai": "^4.3.20",
     "@types/fs-extra": "^11.0.4",
     "@types/mkdirp": "^1.0.2",
@@ -30,15 +29,13 @@
     "@types/uuid": "^9.0.8",
     "@typescript-eslint/eslint-plugin": "^5.62.0",
     "chai": "^4.5.0",
-    "eslint": "^8.57.1",
-    "eslint-config-oclif": "^6.0.62",
+    "eslint": "^9.26.0",
     "mocha": "^10.8.2",
     "nyc": "^15.1.0",
     "oclif": "^4.17.46",
     "rewire": "^9.0.1",
     "sinon": "^21.0.1",
     "ts-node": "^10.9.2",
-    "tsx": "^4.20.3",
     "typescript": "^4.9.5"
   },
   "scripts": {
@@ -85,4 +82,4 @@
     }
   },
   "repository": "https://github.com/contentstack/cli"
-}
\ No newline at end of file
+}
diff --git a/packages/contentstack-import/README.md b/packages/contentstack-import/README.md
index 117795d1d..8ad9a933b 100644
--- a/packages/contentstack-import/README.md
+++ b/packages/contentstack-import/README.md
@@ -47,7 +47,7 @@ $ npm install -g @contentstack/cli-cm-import
 $ csdx COMMAND
 running command...
 $ csdx (--version)
-@contentstack/cli-cm-import/2.0.0-beta.15 darwin-arm64 node-v22.13.1
+@contentstack/cli-cm-import/2.0.0-beta.16 darwin-arm64 node-v22.13.1
 $ csdx --help [COMMAND]
 USAGE
   $ csdx COMMAND
diff --git a/packages/contentstack-import/package.json b/packages/contentstack-import/package.json
index 4b064d9d7..c38c4d4f6 100644
--- a/packages/contentstack-import/package.json
+++ b/packages/contentstack-import/package.json
@@ -21,7 +21,6 @@
     "merge": "^2.1.1",
     "mkdirp": "^1.0.4",
     "promise-limit": "^2.7.0",
-    "uuid": "^9.0.1",
     "winston": "^3.19.0"
   },
   "devDependencies": {
@@ -32,16 +31,12 @@
     "@types/mkdirp": "^1.0.2",
     "@types/mocha": "^8.2.3",
     "@types/node": "^14.18.63",
-    "@types/rewire": "^2.5.30",
-    "@types/tar": "^6.1.13",
-    "@types/uuid": "^9.0.8",
     "@typescript-eslint/eslint-plugin": "^5.62.0",
-    "eslint": "^8.57.1",
+    "eslint": "^9.26.0",
     "eslint-config-oclif": "^6.0.89",
     "mocha": "^10.8.2",
     "nyc": "^15.1.0",
     "oclif": "^4.17.46",
-    "rewire": "^9.0.1",
     "ts-node": "^10.9.2",
     "typescript": "^4.9.5"
   },
@@ -91,4 +86,4 @@
     }
   },
   "repository": "https://github.com/contentstack/cli"
-}
+}
\ No newline at end of file
diff --git a/packages/contentstack-import/src/config/index.ts b/packages/contentstack-import/src/config/index.ts
index a15332baa..e281a0bb3 100644
--- a/packages/contentstack-import/src/config/index.ts
+++ b/packages/contentstack-import/src/config/index.ts
@@ -41,6 +41,7 @@ const config: DefaultConfig = {
       'personalize',
       'custom-roles',
       'workflows',
+      'publishing-rules',
       'entries',
       'variant-entries',
       'labels',
@@ -88,6 +89,11 @@ const config: DefaultConfig = {
       fileName: 'workflows.json',
       invalidKeys: ['stackHeaders', 'urlPath', 'created_at', 'updated_at', 'created_by', 'updated_by'],
     },
+    'publishing-rules': {
+      dirName: 'workflows',
+      fileName: 'publishing-rules.json',
+      invalidKeys: ['stackHeaders', 'urlPath', 'created_at', 'updated_at', 'created_by', 'updated_by'],
+    },
     assets: {
       dirName: 'assets',
       assetBatchLimit: 1,
@@ -488,5 +494,7 @@ const config: DefaultConfig = {
   globalModules: ['webhooks'],
   entriesPublish: true,
 };
+export const PUBLISHING_RULES_APPROVERS_SKIP_MSG =
+  'Skipping import of publish rule approver(s) (roles/users); reconfigure approvers on the target stack.';
 
 export default config;
diff --git a/packages/contentstack-import/src/import/modules/assets.ts b/packages/contentstack-import/src/import/modules/assets.ts
index 80b3f7ef0..e89baadff 100644
--- a/packages/contentstack-import/src/import/modules/assets.ts
+++ b/packages/contentstack-import/src/import/modules/assets.ts
@@ -7,9 +7,8 @@ import isEmpty from 'lodash/isEmpty';
 import uniq from 'lodash/uniq';
 import { existsSync } from 'node:fs';
 import includes from 'lodash/includes';
-import { v4 as uuid } from 'uuid';
 import { resolve as pResolve, join } from 'node:path';
-import { FsUtility, log, handleAndLogError } from '@contentstack/cli-utilities';
+import { FsUtility, log, handleAndLogError, generateUid } from '@contentstack/cli-utilities';
 import { ImportSpaces, type SpaceMapping } from '@contentstack/cli-asset-management';
 import { PATH_CONSTANTS } from '../../constants';
 
@@ -80,9 +79,55 @@ export default class ImportAssets extends BaseClass {
         const progress = this.createNestedProgress(this.currentModuleName);
         let spaceMappings: SpaceMapping[] = [];
 
+        // Resolve the existing default space in the target branch before building options.
+        // This allows the source default space to be imported into the pre-existing target default
+        // space instead of creating a new one.
+        const branchUid = this.importConfig.branchName ?? 'main';
+        let targetDefaultSpaceUid: string | undefined;
+        let targetDefaultWorkspaceUid: string | undefined;
+        try {
+          const branchData = (await this.stack.branch(branchUid).fetch({ include_settings: true })) as Record<
+            string,
+            any
+          >;
+          const linkedWorkspaces = (branchData?.settings?.am_v2?.linked_workspaces ?? []) as Array<{
+            uid: string;
+            space_uid: string;
+            is_default: boolean;
+          }>;
+          const defaultMatches = linkedWorkspaces.filter((w) => w.is_default === true);
+          if (defaultMatches.length > 1) {
+            log.warn(
+              `Target branch "${branchUid}" has ${defaultMatches.length} workspaces with is_default=true; using the first.`,
+              this.importConfig.context,
+            );
+          }
+          if (defaultMatches.length > 0) {
+            targetDefaultSpaceUid = defaultMatches[0].space_uid;
+            targetDefaultWorkspaceUid = defaultMatches[0].uid;
+            log.debug(
+              `Target default space: ${targetDefaultSpaceUid} (workspace uid: ${targetDefaultWorkspaceUid})`,
+              this.importConfig.context,
+            );
+          } else {
+            log.debug(
+              'Target branch has no default workspace; source default space will be created as new.',
+              this.importConfig.context,
+            );
+          }
+        } catch (e) {
+          log.debug(
+            `Could not fetch target branch linked_workspaces for default space detection: ${e}`,
+            this.importConfig.context,
+          );
+        }
+
         try {
           const importer = new ImportSpaces(
-            buildImportSpacesOptions(this.importConfig, this.importConfig.assetManagementUrl),
+            buildImportSpacesOptions(this.importConfig, this.importConfig.assetManagementUrl, {
+              targetDefaultSpaceUid,
+              targetDefaultWorkspaceUid,
+            }),
           );
           importer.setParentProgressManager(progress);
           ({ spaceMappings } = await importer.start());
@@ -181,12 +226,16 @@ export default class ImportAssets extends BaseClass {
         operation?: string;
       }>;
 
-      const newWorkspaces = spaceMappings.map(({ newSpaceUid, workspaceUid }) => ({
-        uid: workspaceUid,
-        space_uid: newSpaceUid,
-        is_default: false,
-        operation: 'LINK' as const,
-      }));
+      // Skip spaces already linked to the branch (e.g. the pre-existing target default space).
+      const alreadyLinkedSpaceUids = new Set(currentLinked.map((w) => w.space_uid));
+      const newWorkspaces = spaceMappings
+        .filter(({ newSpaceUid }) => !alreadyLinkedSpaceUids.has(newSpaceUid))
+        .map(({ newSpaceUid, workspaceUid }) => ({
+          uid: workspaceUid,
+          space_uid: newSpaceUid,
+          is_default: false,
+          operation: 'LINK' as const,
+        }));
 
       const combinedWorkspaces = [...currentLinked, ...newWorkspaces];
 
@@ -570,7 +619,7 @@ export default class ImportAssets extends BaseClass {
       // 2. if there are multiple assets fetched with same query, then check the parent uid against mapper created while importing folders
       // 3. Replace matched assets
       this.rootFolder = {
-        uid: uuid(),
+        uid: generateUid(),
         name: `Import-${formatDate()}`,
         parent_uid: null,
         created_at: null,
diff --git a/packages/contentstack-import/src/import/modules/base-class.ts b/packages/contentstack-import/src/import/modules/base-class.ts
index e0fb3de4e..bd5c46889 100644
--- a/packages/contentstack-import/src/import/modules/base-class.ts
+++ b/packages/contentstack-import/src/import/modules/base-class.ts
@@ -61,7 +61,8 @@ export type ApiModuleType =
   | 'delete-entries'
   | 'create-taxonomies'
   | 'create-terms'
-  | 'import-taxonomy';
+  | 'import-taxonomy'
+  | 'create-publishing-rule';
 
 export type ApiOptions = {
   uid?: string;
@@ -461,6 +462,13 @@ export default abstract class BaseClass {
           .create({ workflow: apiData as WorkflowData })
           .then(onSuccess)
           .catch(onReject);
+      case 'create-publishing-rule':
+        return this.stack
+          .workflow()
+          .publishRule()
+          .create({ publishing_rule: omit(apiData, ['uid']) as any })
+          .then(onSuccess)
+          .catch(onReject);
       case 'create-custom-role':
         return this.stack
           .role()
diff --git a/packages/contentstack-import/src/import/modules/publishing-rules.ts b/packages/contentstack-import/src/import/modules/publishing-rules.ts
new file mode 100644
index 000000000..ca7734585
--- /dev/null
+++ b/packages/contentstack-import/src/import/modules/publishing-rules.ts
@@ -0,0 +1,275 @@
+import chalk from 'chalk';
+import values from 'lodash/values';
+import isEmpty from 'lodash/isEmpty';
+import { join } from 'node:path';
+
+import BaseClass, { ApiOptions } from './base-class';
+import { PUBLISHING_RULES_APPROVERS_SKIP_MSG } from '../../config';
+import { fsUtil, fileHelper, parseErrorPayload, isDuplicatePublishingRuleError } from '../../utils';
+import { log, handleAndLogError } from '@contentstack/cli-utilities';
+import { ModuleClassParams, PublishingRulesConfig } from '../../types';
+
+export default class ImportPublishingRules extends BaseClass {
+  private readonly mapperDirPath: string;
+  private readonly publishingRulesFolderPath: string;
+  private readonly publishingRulesUidMapperPath: string;
+  private readonly createdPublishingRulesPath: string;
+  private readonly failedPublishingRulesPath: string;
+  private readonly publishingRulesConfig: PublishingRulesConfig;
+  private publishingRules: Record<string, unknown>;
+  private publishingRulesUidMapper: Record<string, unknown>;
+  private readonly createdPublishingRules: Record<string, unknown>[];
+  private readonly failedPublishingRules: Record<string, unknown>[];
+  private envUidMapper: Record<string, unknown>;
+  private workflowUidMapper: Record<string, unknown>;
+  private readonly stageUidMapper: Record<string, string> = {};
+
+  constructor({ importConfig, stackAPIClient }: ModuleClassParams) {
+    super({ importConfig, stackAPIClient });
+    this.importConfig.context.module = 'publishing-rules';
+    this.publishingRulesConfig = importConfig.modules['publishing-rules'];
+    this.mapperDirPath = join(this.importConfig.backupDir, 'mapper', 'publishing-rules');
+    this.publishingRulesFolderPath = join(this.importConfig.backupDir, this.publishingRulesConfig.dirName);
+    this.publishingRulesUidMapperPath = join(this.mapperDirPath, 'uid-mapping.json');
+    this.createdPublishingRulesPath = join(this.mapperDirPath, 'success.json');
+    this.failedPublishingRulesPath = join(this.mapperDirPath, 'fails.json');
+    this.publishingRules = {};
+    this.publishingRulesUidMapper = {};
+    this.createdPublishingRules = [];
+    this.failedPublishingRules = [];
+    this.envUidMapper = {};
+    this.workflowUidMapper = {};
+  }
+
+  private static collectOldStageUidToName(
+    exportedWorkflows: Record<string, { workflow_stages?: { uid?: string; name?: string }[] }>,
+  ): Record<string, string> {
+    const map: Record<string, string> = {};
+    for (const workflow of Object.values(exportedWorkflows)) {
+      for (const stage of workflow.workflow_stages ?? []) {
+        if (stage.uid && stage.name) {
+          map[stage.uid] = stage.name;
+        }
+      }
+    }
+    return map;
+  }
+
+  /**
+   * Returns `{ noSuccessMsg: true }` if any rule failed, so the import command skips the generic stack success line.
+   */
+  async start(): Promise<{ noSuccessMsg: true } | void> {
+    const rulesFilePath = join(this.publishingRulesFolderPath, this.publishingRulesConfig.fileName);
+
+    if (!fileHelper.fileExistsSync(rulesFilePath)) {
+      log.info(`No Publishing Rules found - '${rulesFilePath}'`, this.importConfig.context);
+      return;
+    }
+
+    this.publishingRules = (fsUtil.readFile(rulesFilePath, true) as Record<string, unknown>) ?? {};
+    if (isEmpty(this.publishingRules)) {
+      log.info('No Publishing Rules found', this.importConfig.context);
+      return;
+    }
+
+    await fsUtil.makeDirectory(this.mapperDirPath);
+
+    this.publishingRulesUidMapper = this.readUidMappingFile(this.publishingRulesUidMapperPath);
+    this.envUidMapper = this.readMapper('environments');
+    this.workflowUidMapper = this.readMapper('workflows');
+
+    await this.buildStageUidMapper();
+    await this.importPublishingRules();
+
+    if (this.createdPublishingRules?.length) {
+      fsUtil.writeFile(this.createdPublishingRulesPath, this.createdPublishingRules);
+    }
+    if (this.failedPublishingRules?.length) {
+      fsUtil.writeFile(this.failedPublishingRulesPath, this.failedPublishingRules);
+    }
+
+    const successCount = this.createdPublishingRules.length;
+    const failCount = this.failedPublishingRules.length;
+
+    if (failCount > 0 && successCount === 0) {
+      log.error(
+        `Publishing rules import failed! ${failCount} rule(s) could not be imported. Check '${this.failedPublishingRulesPath}' for details.`,
+        this.importConfig.context,
+      );
+    } else if (failCount > 0) {
+      log.warn(
+        `Publishing rules import completed with errors. Imported: ${successCount}, Failed: ${failCount}. Check '${this.failedPublishingRulesPath}' for details.`,
+        this.importConfig.context,
+      );
+    } else {
+      log.success('Publishing rules have been imported successfully!', this.importConfig.context);
+    }
+
+    if (failCount > 0) {
+      return { noSuccessMsg: true };
+    }
+  }
+
+  private readUidMappingFile(path: string): Record<string, unknown> {
+    return fileHelper.fileExistsSync(path) ? (fsUtil.readFile(path, true) as Record<string, unknown>) ?? {} : {};
+  }
+
+  private readMapper(moduleDir: string): Record<string, unknown> {
+    const p = join(this.importConfig.backupDir, 'mapper', moduleDir, 'uid-mapping.json');
+    return this.readUidMappingFile(p);
+  }
+
+  private async importPublishingRules(): Promise<void> {
+    const apiContent = values(this.publishingRules) as Record<string, unknown>[];
+    log.debug(`Importing ${apiContent.length} publishing rule(s)`, this.importConfig.context);
+
+    const onSuccess = ({ response, apiData }: { response: { uid: string }; apiData: { uid: string } }) => {
+      const { uid } = apiData;
+      this.createdPublishingRules.push(response as unknown as Record<string, unknown>);
+      this.publishingRulesUidMapper[uid] = response.uid;
+      log.success(`Publishing rule imported successfully (${uid} → ${response.uid})`, this.importConfig.context);
+      fsUtil.writeFile(this.publishingRulesUidMapperPath, this.publishingRulesUidMapper);
+    };
+
+    const onReject = ({ error, apiData }: { error: unknown; apiData: Record<string, unknown> }) => {
+      const uid = apiData.uid as string;
+      const parsed = parseErrorPayload(error);
+
+      if (isDuplicatePublishingRuleError(parsed, error)) {
+        log.info(`Publishing rule '${uid}' already exists`, this.importConfig.context);
+        return;
+      }
+
+      this.failedPublishingRules.push(apiData);
+      handleAndLogError(
+        error as Error,
+        { ...this.importConfig.context, publishingRuleUid: uid },
+        `Publishing rule '${uid}' failed to import`,
+      );
+    };
+
+    await this.makeConcurrentCall(
+      {
+        apiContent,
+        processName: 'import publishing rules',
+        apiParams: {
+          serializeData: this.serializePublishingRules.bind(this),
+          reject: onReject,
+          resolve: onSuccess,
+          entity: 'create-publishing-rule',
+          includeParamOnCompletion: true,
+        },
+        concurrencyLimit: this.importConfig.fetchConcurrency || 1,
+      },
+      undefined,
+      false,
+    );
+  }
+
+  private mergeFetchedWorkflowStages(
+    workflow: { workflow_stages?: { uid?: string; name?: string }[] },
+    oldStageUidToName: Record<string, string>,
+  ): void {
+    for (const newStage of workflow.workflow_stages ?? []) {
+      const oldUid = Object.keys(oldStageUidToName).find((u) => oldStageUidToName[u] === newStage.name);
+      if (oldUid && newStage.uid) {
+        this.stageUidMapper[oldUid] = newStage.uid;
+      }
+    }
+  }
+
+  private async buildStageUidMapper(): Promise<void> {
+    const wf = this.importConfig.modules.workflows as { dirName: string; fileName: string };
+    const workflowsFilePath = join(this.importConfig.backupDir, wf.dirName, wf.fileName);
+
+    if (!fileHelper.fileExistsSync(workflowsFilePath)) {
+      log.debug('No exported workflows file; stage UID mapping skipped', this.importConfig.context);
+      return;
+    }
+
+    const exportedWorkflows = fsUtil.readFile(workflowsFilePath, true) as Record<
+      string,
+      { workflow_stages?: { uid?: string; name?: string }[] }
+    > | null;
+    if (!exportedWorkflows) return;
+
+    const oldStageUidToName = ImportPublishingRules.collectOldStageUidToName(exportedWorkflows);
+
+    for (const newWorkflowUid of Object.values(this.workflowUidMapper)) {
+      try {
+        const workflow = await this.stack.workflow(newWorkflowUid as string).fetch();
+        this.mergeFetchedWorkflowStages(
+          workflow as { workflow_stages?: { uid?: string; name?: string }[] },
+          oldStageUidToName,
+        );
+      } catch (error: unknown) {
+        log.debug(`Stage mapping: could not fetch workflow '${newWorkflowUid}'`, this.importConfig.context);
+        handleAndLogError(error as Error, { ...this.importConfig.context });
+      }
+    }
+
+    log.debug(`Stage UID mapper: ${Object.keys(this.stageUidMapper).length} entr(y/ies)`, this.importConfig.context);
+  }
+
+  private stripApprovers(rule: Record<string, unknown>): void {
+    if (rule.approvers == null) return;
+
+    const a = rule.approvers as { roles?: unknown[]; users?: unknown[] };
+    const hadContent = (Array.isArray(a.roles) && a.roles.length > 0) || (Array.isArray(a.users) && a.users.length > 0);
+    if (hadContent) {
+      log.info(chalk.yellow(PUBLISHING_RULES_APPROVERS_SKIP_MSG), this.importConfig.context);
+    }
+    rule.approvers = { roles: [], users: [] };
+  }
+
+  private remapReference(
+    rule: Record<string, unknown>,
+    field: 'workflow' | 'environment',
+    mapper: Record<string, unknown>,
+  ): void {
+    const current = rule[field] as string | undefined;
+    if (!current) return;
+    const mapped = mapper[current] as string | undefined;
+    if (mapped) {
+      rule[field] = mapped;
+      log.debug(`${field} UID remapped`, this.importConfig.context);
+    } else {
+      log.debug(`No ${field} mapping for ${current}; leaving as-is`, this.importConfig.context);
+    }
+  }
+
+  serializePublishingRules(apiOptions: ApiOptions): ApiOptions {
+    const rule = apiOptions.apiData as Record<string, unknown>;
+    const ruleUid = rule.uid as string;
+
+    if (ruleUid in this.publishingRulesUidMapper) {
+      log.info(
+        `Publishing rule '${ruleUid}' already exists. Skipping it to avoid duplicates!`,
+        this.importConfig.context,
+      );
+      apiOptions.entity = undefined;
+      return apiOptions;
+    }
+
+    const oldUid = ruleUid;
+    delete rule.uid;
+
+    this.stripApprovers(rule);
+    this.remapReference(rule, 'workflow', this.workflowUidMapper);
+    this.remapReference(rule, 'environment', this.envUidMapper);
+
+    if (rule.workflow_stage) {
+      const stage = rule.workflow_stage as string;
+      const mappedStage = this.stageUidMapper[stage];
+      if (mappedStage) {
+        rule.workflow_stage = mappedStage;
+        log.debug('workflow_stage UID remapped', this.importConfig.context);
+      } else {
+        log.debug(`No workflow_stage mapping for ${stage}; leaving as-is`, this.importConfig.context);
+      }
+    }
+
+    apiOptions.apiData = { ...rule, uid: oldUid };
+    return apiOptions;
+  }
+}
diff --git a/packages/contentstack-import/src/types/default-config.ts b/packages/contentstack-import/src/types/default-config.ts
index 29e859806..f52069546 100644
--- a/packages/contentstack-import/src/types/default-config.ts
+++ b/packages/contentstack-import/src/types/default-config.ts
@@ -49,6 +49,11 @@ export default interface DefaultConfig {
       fileName: string;
       invalidKeys: string[];
     };
+    'publishing-rules': {
+      dirName: string;
+      fileName: string;
+      invalidKeys: string[];
+    };
     assets: {
       dirName: string;
       assetBatchLimit: number;
diff --git a/packages/contentstack-import/src/types/index.ts b/packages/contentstack-import/src/types/index.ts
index a73584b36..431bbd67b 100644
--- a/packages/contentstack-import/src/types/index.ts
+++ b/packages/contentstack-import/src/types/index.ts
@@ -47,6 +47,7 @@ export type Modules =
   | 'content-types'
   | 'custom-roles'
   | 'workflows'
+  | 'publishing-rules'
   | 'labels'
   | 'marketplace-apps'
   | 'taxonomies'
@@ -95,6 +96,12 @@ export interface WorkflowConfig {
   invalidKeys: string[];
 }
 
+export interface PublishingRulesConfig {
+  dirName: string;
+  fileName: string;
+  invalidKeys: string[];
+}
+
 export interface CustomRoleConfig {
   dirName: string;
   fileName: string;
diff --git a/packages/contentstack-import/src/utils/build-import-spaces-options.ts b/packages/contentstack-import/src/utils/build-import-spaces-options.ts
index 32e57c8ce..22d99c5e6 100644
--- a/packages/contentstack-import/src/utils/build-import-spaces-options.ts
+++ b/packages/contentstack-import/src/utils/build-import-spaces-options.ts
@@ -6,10 +6,14 @@ import type ImportConfig from '../types/import-config';
 /**
  * Maps stack `ImportConfig` and AM base URL into a single `ImportSpacesOptions` for the AM package
  * (variants-style: one flat object; `ImportSpaces` splits API vs context internally).
+ *
+ * Pass `overrides` to inject default-space mapping data fetched from the target branch before
+ * calling this function (see `ImportAssets.start()` for the fetch logic).
  */
 export function buildImportSpacesOptions(
   importConfig: ImportConfig,
   assetManagementUrl: string,
+  overrides?: Pick<ImportSpacesOptions, 'targetDefaultSpaceUid' | 'targetDefaultWorkspaceUid'>,
 ): ImportSpacesOptions {
   const am = importConfig.modules['asset-management'];
   const org_uid = importConfig.org_uid ?? '';
@@ -40,5 +44,7 @@ export function buildImportSpacesOptions(
     mapperUidFileName: am?.mapperUidFileName ?? PATH_CONSTANTS.FILES.UID_MAPPING,
     mapperUrlFileName: am?.mapperUrlFileName ?? PATH_CONSTANTS.FILES.URL_MAPPING,
     mapperSpaceUidFileName: am?.mapperSpaceUidFileName ?? PATH_CONSTANTS.FILES.SPACE_UID_MAPPING,
+    targetDefaultSpaceUid: overrides?.targetDefaultSpaceUid,
+    targetDefaultWorkspaceUid: overrides?.targetDefaultWorkspaceUid,
   };
 }
diff --git a/packages/contentstack-import/src/utils/index.ts b/packages/contentstack-import/src/utils/index.ts
index e2d717409..0694f415b 100644
--- a/packages/contentstack-import/src/utils/index.ts
+++ b/packages/contentstack-import/src/utils/index.ts
@@ -29,3 +29,4 @@ export * from './common-helper';
 export { lookUpTaxonomy, lookUpTerms } from './taxonomies-helper';
 export { MODULE_CONTEXTS, MODULE_NAMES, PROCESS_NAMES, PROCESS_STATUS } from './constants';
 export { buildImportSpacesOptions } from './build-import-spaces-options';
+export { parseErrorPayload, isDuplicatePublishingRuleError } from './publishing-rules-helper';
diff --git a/packages/contentstack-import/src/utils/progress-strategy-registry.ts b/packages/contentstack-import/src/utils/progress-strategy-registry.ts
index 5a391317d..0d5137346 100644
--- a/packages/contentstack-import/src/utils/progress-strategy-registry.ts
+++ b/packages/contentstack-import/src/utils/progress-strategy-registry.ts
@@ -10,8 +10,34 @@ import {
   CustomProgressStrategy,
   DefaultProgressStrategy,
 } from '@contentstack/cli-utilities';
+import { isSpaceProcessName } from '@contentstack/cli-asset-management';
 import { MODULE_CONTEXTS, MODULE_NAMES, PROCESS_NAMES } from './constants';
 
+/**
+ * Sum the totals/success/failure counts across every per-space process row in
+ * the multibar. Used by the AM 2.0 Assets strategy so the final import summary
+ * reports total assets-across-all-spaces instead of the placeholder row.
+ *
+ * Returns null when no per-space rows exist, letting the strategy fall back to
+ * legacy process names.
+ */
+function aggregateSpaceProcesses(
+  processes: Map<string, { total: number; successCount: number; failureCount: number }>,
+): { total: number; success: number; failures: number } | null {
+  let total = 0;
+  let success = 0;
+  let failures = 0;
+  let found = false;
+  for (const [name, data] of processes) {
+    if (!isSpaceProcessName(name)) continue;
+    found = true;
+    total += data.total;
+    success += data.successCount;
+    failures += data.failureCount;
+  }
+  return found ? { total, success, failures } : null;
+}
+
 // Wrap all registrations in try-catch to prevent module loading errors
 try {
   // Register strategy for Content Types - use Create as primary process
@@ -33,6 +59,11 @@ try {
       };
     }
 
+    // Asset Management 2.0 (per-space layout): sum every "Space *" row so the
+    // final summary reports total assets-across-all-spaces.
+    const spaceTotals = aggregateSpaceProcesses(processes);
+    if (spaceTotals) return spaceTotals;
+
     return null; // Fall back to default aggregation
   }),
 );
diff --git a/packages/contentstack-import/src/utils/publishing-rules-helper.ts b/packages/contentstack-import/src/utils/publishing-rules-helper.ts
new file mode 100644
index 000000000..b7f3b44ec
--- /dev/null
+++ b/packages/contentstack-import/src/utils/publishing-rules-helper.ts
@@ -0,0 +1,32 @@
+/**
+ * Helpers for publishing rules import (API error shape, duplicate detection).
+ */
+
+export function parseErrorPayload(error: unknown): {
+  errors?: Record<string, unknown>;
+  error_message?: string;
+} | null {
+  if (!error || typeof error !== 'object') return null;
+  const e = error as { message?: string; errors?: Record<string, unknown> };
+  if (e.errors) return e;
+  if (e.message && typeof e.message === 'string') {
+    try {
+      return JSON.parse(e.message) as { errors?: Record<string, unknown>; error_message?: string };
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+export function isDuplicatePublishingRuleError(
+  parsed: { errors?: Record<string, unknown>; error_message?: string } | null,
+  raw: unknown,
+): boolean {
+  const errors = parsed?.errors ?? (raw as { errors?: Record<string, unknown> })?.errors;
+  if (errors?.name || errors?.['publishing_rule.name'] || errors?.['publish_rule.name']) {
+    return true;
+  }
+  const msg = parsed?.error_message;
+  return typeof msg === 'string' && /already exists|duplicate/i.test(msg);
+}
diff --git a/packages/contentstack-import/test/unit/import/module-importer.test.ts b/packages/contentstack-import/test/unit/import/module-importer.test.ts
index 6c0767162..ac78a9c9e 100644
--- a/packages/contentstack-import/test/unit/import/module-importer.test.ts
+++ b/packages/contentstack-import/test/unit/import/module-importer.test.ts
@@ -3,7 +3,6 @@ import sinon from 'sinon';
 import { ImportConfig, Modules } from '../../../src/types';
 import { configHandler } from '@contentstack/cli-utilities';
 import ModuleImporter from '../../../src/import/module-importer';
-import * as utilsModule from '../../../src/utils';
 
 describe('ModuleImporter', () => {
   let moduleImporter: ModuleImporter;
@@ -94,12 +93,11 @@ describe('ModuleImporter', () => {
     const backupHandlerModule = require('../../../src/utils/backup-handler');
     backupHandlerStub = sandbox.stub(backupHandlerModule, 'default').resolves('/test/backup');
 
-    // Stub on the same `../utils` barrel ModuleImporter imports from — stubbing `common-helper`
-    // directly can miss the binding CI uses (re-exports), so the real `masterLocalDetails` runs.
-    masterLocalDetailsStub = sandbox.stub(utilsModule, 'masterLocalDetails').resolves({ code: 'en-us' });
-
-    const sanitizeStackModule = require('../../../src/utils/common-helper');
-    sanitizeStackStub = sandbox.stub(sanitizeStackModule, 'sanitizeStack').resolves();
+    // Stub on `common-helper`: ts-node emits `export *` on the utils barrel as non-configurable getters,
+    // which Sinon cannot stub; the barrel getters forward to the same live binding as common-helper.
+    const commonHelperModule = require('../../../src/utils/common-helper');
+    masterLocalDetailsStub = sandbox.stub(commonHelperModule, 'masterLocalDetails').resolves({ code: 'en-us' });
+    sanitizeStackStub = sandbox.stub(commonHelperModule, 'sanitizeStack').resolves();
 
     const setupBranchModule = require('../../../src/utils/setup-branch');
     setupBranchConfigStub = sandbox.stub(setupBranchModule, 'setupBranchConfig').resolves();
diff --git a/packages/contentstack-import/test/unit/import/modules/assets.test.ts b/packages/contentstack-import/test/unit/import/modules/assets.test.ts
index 8231a03ce..45cc20965 100644
--- a/packages/contentstack-import/test/unit/import/modules/assets.test.ts
+++ b/packages/contentstack-import/test/unit/import/modules/assets.test.ts
@@ -1091,4 +1091,102 @@ describe('ImportAssets', () => {
       expect(result[99].parent_uid).to.equal('folder-98');
     });
   });
+
+  describe('linkImportedAmSpacesToBranch() — duplicate prevention', () => {
+    let branchFetchStub: sinon.SinonStub;
+    let branchUpdateSettingsStub: sinon.SinonStub;
+    let branchStub: sinon.SinonStub;
+
+    beforeEach(() => {
+      branchFetchStub = sinon.stub();
+      branchUpdateSettingsStub = sinon.stub().resolves();
+      branchStub = sinon.stub().returns({
+        fetch: branchFetchStub,
+        updateSettings: branchUpdateSettingsStub,
+      });
+      // stack is a getter-only property on BaseClass; override via defineProperty.
+      Object.defineProperty(importAssets, 'stack', {
+        get: () => ({ branch: branchStub }),
+        configurable: true,
+      });
+    });
+
+    it('should skip space mappings whose newSpaceUid is already linked to the branch', async () => {
+      branchFetchStub.resolves({
+        settings: {
+          am_v2: {
+            linked_workspaces: [
+              { uid: 'ws-3', space_uid: 'target-space-3', is_default: true },
+            ],
+          },
+        },
+      });
+
+      const spaceMappings = [
+        { oldSpaceUid: 'am-space-1', newSpaceUid: 'target-space-3', workspaceUid: 'ws-3', isDefault: true },
+      ];
+
+      await (importAssets as any).linkImportedAmSpacesToBranch(spaceMappings);
+
+      expect(branchUpdateSettingsStub.callCount).to.equal(1);
+      const updatedWorkspaces =
+        branchUpdateSettingsStub.firstCall.args[0].branch.settings.am_v2.linked_workspaces;
+      // The existing entry stays; no new entry appended for target-space-3.
+      expect(updatedWorkspaces).to.have.lengthOf(1);
+      expect(updatedWorkspaces[0].space_uid).to.equal('target-space-3');
+      expect(updatedWorkspaces[0].uid).to.equal('ws-3');
+    });
+
+    it('should append only the non-default (new) space, not the already-linked default space', async () => {
+      branchFetchStub.resolves({
+        settings: {
+          am_v2: {
+            linked_workspaces: [
+              { uid: 'ws-3', space_uid: 'target-space-3', is_default: true },
+            ],
+          },
+        },
+      });
+
+      const spaceMappings = [
+        { oldSpaceUid: 'am-space-1', newSpaceUid: 'target-space-3', workspaceUid: 'ws-3', isDefault: true },
+        { oldSpaceUid: 'am-space-2', newSpaceUid: 'brand-new-space', workspaceUid: 'main', isDefault: false },
+      ];
+
+      await (importAssets as any).linkImportedAmSpacesToBranch(spaceMappings);
+
+      const updatedWorkspaces =
+        branchUpdateSettingsStub.firstCall.args[0].branch.settings.am_v2.linked_workspaces;
+      // Existing default + one new space = 2 total.
+      expect(updatedWorkspaces).to.have.lengthOf(2);
+      expect(updatedWorkspaces.map((w: any) => w.space_uid)).to.include.members([
+        'target-space-3',
+        'brand-new-space',
+      ]);
+    });
+
+    it('should append all mappings when none are already linked', async () => {
+      branchFetchStub.resolves({
+        settings: { am_v2: { linked_workspaces: [] } },
+      });
+
+      const spaceMappings = [
+        { oldSpaceUid: 'am-space-1', newSpaceUid: 'new-space-1', workspaceUid: 'main', isDefault: true },
+        { oldSpaceUid: 'am-space-2', newSpaceUid: 'new-space-2', workspaceUid: 'main', isDefault: false },
+      ];
+
+      await (importAssets as any).linkImportedAmSpacesToBranch(spaceMappings);
+
+      const updatedWorkspaces =
+        branchUpdateSettingsStub.firstCall.args[0].branch.settings.am_v2.linked_workspaces;
+      expect(updatedWorkspaces).to.have.lengthOf(2);
+    });
+
+    it('should do nothing when spaceMappings is empty', async () => {
+      await (importAssets as any).linkImportedAmSpacesToBranch([]);
+
+      expect(branchFetchStub.callCount).to.equal(0);
+      expect(branchUpdateSettingsStub.callCount).to.equal(0);
+    });
+  });
 });
diff --git a/packages/contentstack-import/test/unit/import/modules/locales.test.ts b/packages/contentstack-import/test/unit/import/modules/locales.test.ts
index 5bc5e8f7f..f999c0948 100644
--- a/packages/contentstack-import/test/unit/import/modules/locales.test.ts
+++ b/packages/contentstack-import/test/unit/import/modules/locales.test.ts
@@ -49,6 +49,11 @@ describe('ImportLocales', () => {
         webhooks: { dirName: 'webhooks', fileName: 'webhooks.json' },
         releases: { dirName: 'releases', fileName: 'releases.json', invalidKeys: ['uid'] },
         workflows: { dirName: 'workflows', fileName: 'workflows.json', invalidKeys: ['uid'] },
+        'publishing-rules': {
+          dirName: 'workflows',
+          fileName: 'publishing-rules.json',
+          invalidKeys: ['uid'],
+        },
         assets: {
           dirName: 'assets',
           assetBatchLimit: 10,
diff --git a/packages/contentstack-import/test/unit/import/modules/publishing-rules.test.ts b/packages/contentstack-import/test/unit/import/modules/publishing-rules.test.ts
new file mode 100644
index 000000000..26aa3f4a7
--- /dev/null
+++ b/packages/contentstack-import/test/unit/import/modules/publishing-rules.test.ts
@@ -0,0 +1,333 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { join } from 'node:path';
+import ImportPublishingRules from '../../../../src/import/modules/publishing-rules';
+import { ImportConfig } from '../../../../src/types';
+describe('ImportPublishingRules', () => {
+  const BACKUP = '/test/backup';
+  const rulesFile = join(BACKUP, 'workflows', 'publishing-rules.json');
+  const workflowsExportFile = join(BACKUP, 'workflows', 'workflows.json');
+  const workflowMapperFile = join(BACKUP, 'mapper', 'workflows', 'uid-mapping.json');
+  const envMapperFile = join(BACKUP, 'mapper', 'environments', 'uid-mapping.json');
+  const publishingMapperFile = join(BACKUP, 'mapper', 'publishing-rules', 'uid-mapping.json');
+
+  let importPublishingRules: ImportPublishingRules;
+  let mockStackClient: any;
+  let mockImportConfig: ImportConfig;
+  let fsUtilStub: any;
+  let fileHelperStub: any;
+  let makeConcurrentCallStub: sinon.SinonStub;
+  let logStub: { info: sinon.SinonStub; debug: sinon.SinonStub; success: sinon.SinonStub; error: sinon.SinonStub; warn: sinon.SinonStub };
+  beforeEach(() => {
+    fsUtilStub = {
+      readFile: sinon.stub(),
+      writeFile: sinon.stub(),
+      makeDirectory: sinon.stub().resolves(),
+    };
+
+    fileHelperStub = {
+      fileExistsSync: sinon.stub(),
+    };
+
+    sinon.replace(require('../../../../src/utils'), 'fileHelper', fileHelperStub);
+    sinon.replaceGetter(require('../../../../src/utils'), 'fsUtil', () => fsUtilStub);
+
+    const fetchWorkflowStub = sinon.stub().resolves({
+      workflow_stages: [{ uid: 'stage-new', name: 'Review' }],
+    });
+    mockStackClient = {
+      workflow: sinon.stub().returns({
+        fetch: fetchWorkflowStub,
+      }),
+    };
+
+    mockImportConfig = {
+      apiKey: 'test',
+      backupDir: BACKUP,
+      data: '/test/content',
+      contentVersion: 1,
+      region: 'us',
+      fetchConcurrency: 2,
+      context: {
+        command: 'cm:stacks:import',
+        module: 'publishing-rules',
+        userId: 'user-123',
+        email: 'test@example.com',
+        sessionId: 'session-123',
+        apiKey: 'test',
+        orgId: 'org-123',
+        authenticationMethod: 'Basic Auth',
+      },
+      modules: {
+        workflows: {
+          dirName: 'workflows',
+          fileName: 'workflows.json',
+          invalidKeys: ['uid'],
+        },
+        'publishing-rules': {
+          dirName: 'workflows',
+          fileName: 'publishing-rules.json',
+          invalidKeys: ['uid'],
+        },
+      },
+    } as any;
+
+    importPublishingRules = new ImportPublishingRules({
+      importConfig: mockImportConfig as any,
+      stackAPIClient: mockStackClient,
+      moduleName: 'publishing-rules',
+    });
+
+    makeConcurrentCallStub = sinon.stub(importPublishingRules as any, 'makeConcurrentCall').resolves();
+
+    const cliUtilities = require('@contentstack/cli-utilities');
+    logStub = {
+      info: sinon.stub(),
+      debug: sinon.stub(),
+      success: sinon.stub(),
+      error: sinon.stub(),
+      warn: sinon.stub(),
+    };
+    sinon.stub(cliUtilities, 'log').value(logStub);
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  describe('Constructor', () => {
+    it('sets context.module to publishing-rules and derives exact paths from backupDir and config', () => {
+      expect(mockImportConfig.context.module).to.equal('publishing-rules');
+      expect(importPublishingRules['mapperDirPath']).to.equal(join(BACKUP, 'mapper', 'publishing-rules'));
+      expect(importPublishingRules['publishingRulesFolderPath']).to.equal(join(BACKUP, 'workflows'));
+      expect(importPublishingRules['publishingRulesUidMapperPath']).to.equal(publishingMapperFile);
+      expect(importPublishingRules['createdPublishingRulesPath']).to.equal(
+        join(BACKUP, 'mapper', 'publishing-rules', 'success.json'),
+      );
+      expect(importPublishingRules['failedPublishingRulesPath']).to.equal(
+        join(BACKUP, 'mapper', 'publishing-rules', 'fails.json'),
+      );
+    });
+
+    it('initializes empty rules, mappers, and result arrays', () => {
+      expect(importPublishingRules['publishingRules']).to.deep.equal({});
+      expect(importPublishingRules['publishingRulesUidMapper']).to.deep.equal({});
+      expect(importPublishingRules['createdPublishingRules']).to.deep.equal([]);
+      expect(importPublishingRules['failedPublishingRules']).to.deep.equal([]);
+      expect(importPublishingRules['envUidMapper']).to.deep.equal({});
+      expect(importPublishingRules['workflowUidMapper']).to.deep.equal({});
+      expect(importPublishingRules['stageUidMapper']).to.deep.equal({});
+    });
+  });
+
+  describe('start()', () => {
+    it('returns undefined and logs missing file path when rules file does not exist', async () => {
+      fileHelperStub.fileExistsSync.withArgs(rulesFile).returns(false);
+
+      const result = await importPublishingRules.start();
+
+      expect(result).to.equal(undefined);
+      expect(makeConcurrentCallStub.called).to.be.false;
+      expect(logStub.info.firstCall.args[0]).to.include(rulesFile);
+    });
+
+    it('returns undefined when rules file exists but payload is empty; arrays stay empty', async () => {
+      fileHelperStub.fileExistsSync.withArgs(rulesFile).returns(true);
+      fsUtilStub.readFile.withArgs(rulesFile, true).returns({});
+
+      const result = await importPublishingRules.start();
+
+      expect(result).to.equal(undefined);
+      expect(makeConcurrentCallStub.called).to.be.false;
+      expect(importPublishingRules['createdPublishingRules']).to.deep.equal([]);
+      expect(importPublishingRules['failedPublishingRules']).to.deep.equal([]);
+    });
+
+    it('passes one apiContent item per rule and binds serializeData to serializePublishingRules', async () => {
+      const rules = {
+        r1: { uid: 'r1', name: 'Rule 1' },
+        r2: { uid: 'r2', name: 'Rule 2' },
+      };
+      fileHelperStub.fileExistsSync.callsFake((p: string) => {
+        if (p === rulesFile) return true;
+        if (p === workflowsExportFile || p === workflowMapperFile || p === envMapperFile || p === publishingMapperFile) {
+          return false;
+        }
+        return false;
+      });
+      fsUtilStub.readFile.callsFake((p: string) => {
+        if (p === rulesFile) return rules;
+        return {};
+      });
+
+      await importPublishingRules.start();
+
+      expect(makeConcurrentCallStub.calledOnce).to.be.true;
+      const callArgs = makeConcurrentCallStub.firstCall.args[0];
+      expect(callArgs.apiContent).to.have.length(2);
+      expect(callArgs.processName).to.equal('import publishing rules');
+      expect(callArgs.apiParams.entity).to.equal('create-publishing-rule');
+      const serialized = callArgs.apiParams.serializeData({
+        apiData: { uid: 'r1', name: 'Rule 1' },
+        entity: 'create-publishing-rule',
+      });
+      expect(serialized.apiData).to.deep.include({ name: 'Rule 1', uid: 'r1' });
+      expect(serialized.entity).to.equal('create-publishing-rule');
+    });
+
+    it('builds stageUidMapper from exported workflows and fetched target workflow stages by name', async () => {
+      fileHelperStub.fileExistsSync.callsFake((p: string) => {
+        if (p === rulesFile) return true;
+        if (p === workflowsExportFile) return true;
+        if (p === workflowMapperFile) return true;
+        if (p === envMapperFile || p === publishingMapperFile) return false;
+        return false;
+      });
+      fsUtilStub.readFile.callsFake((p: string) => {
+        if (p === rulesFile) return { r1: { uid: 'r1', name: 'R' } };
+        if (p === workflowsExportFile) {
+          return {
+            expWf: { workflow_stages: [{ uid: 'stage-old', name: 'Review' }] },
+          };
+        }
+        if (p === workflowMapperFile) return { oldWf: 'newWf' };
+        return {};
+      });
+
+      await importPublishingRules.start();
+
+      expect(importPublishingRules['stageUidMapper']).to.deep.equal({ 'stage-old': 'stage-new' });
+      expect(mockStackClient.workflow.calledWith('newWf')).to.be.true;
+    });
+
+    it('returns { noSuccessMsg: true } when a rule fails to import (non-duplicate error)', async () => {
+      fileHelperStub.fileExistsSync.callsFake((p: string) => p === rulesFile);
+      fsUtilStub.readFile.callsFake((p: string) => (p === rulesFile ? { r1: { uid: 'r1', name: 'R' } } : {}));
+
+      makeConcurrentCallStub.callsFake(async (env: any) => {
+        const { apiParams, apiContent } = env;
+        for (const element of apiContent) {
+          apiParams.apiData = element;
+          let opts = { ...apiParams, apiData: { ...element } };
+          opts = apiParams.serializeData(opts);
+          if (opts.entity) {
+            await apiParams.reject({ error: new Error('network'), apiData: opts.apiData });
+          }
+        }
+      });
+
+      const result = await importPublishingRules.start();
+
+      expect(result).to.deep.equal({ noSuccessMsg: true });
+      expect(importPublishingRules['failedPublishingRules']).to.have.length(1);
+      expect(importPublishingRules['failedPublishingRules'][0].uid).to.equal('r1');
+      expect(String(logStub.error.firstCall?.args[0] ?? '')).to.include('could not be imported');
+    });
+
+    it('returns undefined when import succeeds with no failures', async () => {
+      fileHelperStub.fileExistsSync.callsFake((p: string) => p === rulesFile);
+      fsUtilStub.readFile.callsFake((p: string) => (p === rulesFile ? { r1: { uid: 'r1', name: 'R' } } : {}));
+
+      makeConcurrentCallStub.callsFake(async (env: any) => {
+        const { apiParams, apiContent } = env;
+        for (const element of apiContent) {
+          apiParams.apiData = element;
+          let opts = { ...apiParams, apiData: { ...element } };
+          opts = apiParams.serializeData(opts);
+          if (opts.entity) {
+            await apiParams.resolve({ response: { uid: 'new-r1' }, apiData: opts.apiData });
+          }
+        }
+      });
+
+      const result = await importPublishingRules.start();
+
+      expect(result).to.equal(undefined);
+      expect(importPublishingRules['failedPublishingRules']).to.deep.equal([]);
+      expect(importPublishingRules['publishingRulesUidMapper']).to.deep.equal({ r1: 'new-r1' });
+      expect(logStub.success.calledWith('Publishing rules have been imported successfully!', mockImportConfig.context)).to.be
+        .true;
+    });
+  });
+
+  describe('serializePublishingRules', () => {
+    it('clears entity when rule uid already in mapper; leaves apiData.uid unchanged', () => {
+      importPublishingRules['publishingRulesUidMapper'] = { 'rule-1': 'mapped-1' };
+
+      const apiOptions: any = {
+        apiData: { uid: 'rule-1', name: 'N' },
+        entity: 'create-publishing-rule',
+      };
+
+      const out = importPublishingRules.serializePublishingRules(apiOptions);
+
+      expect(out.entity).to.equal(undefined);
+      expect(out.apiData).to.deep.equal({ uid: 'rule-1', name: 'N' });
+      expect(String(logStub.info.firstCall?.args[0] ?? '')).to.match(/already exists\. Skipping/);
+    });
+
+    it('remaps workflow, environment, workflow_stage and strips approvers; apiData carries uid for completion handler', () => {
+      const pr = importPublishingRules as any;
+      pr.workflowUidMapper = { wfOld: 'wfNew' };
+      pr.envUidMapper = { envOld: 'envNew' };
+      Object.keys(pr.stageUidMapper).forEach((k) => delete pr.stageUidMapper[k]);
+      pr.stageUidMapper.stOld = 'stNew';
+
+      const apiOptions: any = {
+        apiData: {
+          uid: 'pr-1',
+          name: 'PR',
+          workflow: 'wfOld',
+          environment: 'envOld',
+          workflow_stage: 'stOld',
+          approvers: { roles: ['r1'], users: ['u1'] },
+        },
+        entity: 'create-publishing-rule',
+      };
+
+      const out = importPublishingRules.serializePublishingRules(apiOptions);
+
+      expect(out.entity).to.equal('create-publishing-rule');
+      expect(out.apiData).to.deep.equal({
+        uid: 'pr-1',
+        name: 'PR',
+        workflow: 'wfNew',
+        environment: 'envNew',
+        workflow_stage: 'stNew',
+        approvers: { roles: [], users: [] },
+      });
+      const infoArgs = logStub.info.getCalls().map((c) => c.args[0]);
+      expect(infoArgs.some((msg) => String(msg).includes('Skipping import of publish rule approver'))).to.be.true;
+    });
+  });
+
+  describe('importPublishingRules callbacks', () => {
+    beforeEach(() => {
+      importPublishingRules['publishingRules'] = { r1: { uid: 'r1', name: 'R' } };
+    });
+
+    it('onSuccess updates mapper and persists uid-mapping.json with expected payload', async () => {
+      await (importPublishingRules as any).importPublishingRules();
+
+      const onSuccess = makeConcurrentCallStub.firstCall.args[0].apiParams.resolve;
+      await onSuccess({ response: { uid: 'created-uid', name: 'R' }, apiData: { uid: 'r1', name: 'R' } });
+
+      expect(importPublishingRules['createdPublishingRules']).to.deep.equal([{ uid: 'created-uid', name: 'R' }]);
+      expect(importPublishingRules['publishingRulesUidMapper']).to.deep.equal({ r1: 'created-uid' });
+      expect(fsUtilStub.writeFile.calledWith(publishingMapperFile, { r1: 'created-uid' })).to.be.true;
+    });
+
+    it('onReject for duplicate error does not append to failedPublishingRules', async () => {
+      await (importPublishingRules as any).importPublishingRules();
+
+      const onReject = makeConcurrentCallStub.firstCall.args[0].apiParams.reject;
+      await onReject({
+        error: { errors: { name: 'taken' } },
+        apiData: { uid: 'r1', name: 'R' },
+      });
+
+      expect(importPublishingRules['failedPublishingRules']).to.deep.equal([]);
+      expect(logStub.info.calledWith(`Publishing rule 'r1' already exists`, mockImportConfig.context)).to.be.true;
+    });
+  });
+});
diff --git a/packages/contentstack-import/test/unit/utils/build-import-spaces-options.test.ts b/packages/contentstack-import/test/unit/utils/build-import-spaces-options.test.ts
new file mode 100644
index 000000000..c21f739f0
--- /dev/null
+++ b/packages/contentstack-import/test/unit/utils/build-import-spaces-options.test.ts
@@ -0,0 +1,101 @@
+import { expect } from 'chai';
+import { buildImportSpacesOptions } from '../../../src/utils/build-import-spaces-options';
+import type { ImportConfig } from '../../../src/types';
+
+describe('buildImportSpacesOptions', () => {
+  const baseConfig = {
+    contentDir: '/tmp/content',
+    apiKey: 'stack-api-key',
+    org_uid: 'org-123',
+    host: 'https://api.contentstack.io/v3',
+    region: { cma: 'https://api.contentstack.io/v3' },
+    source_stack: 'source-api-key',
+    context: {} as any,
+    backupDir: '/tmp/backup',
+    fetchConcurrency: 5,
+    modules: {
+      'asset-management': {
+        dirName: 'spaces',
+        uploadAssetsConcurrency: 3,
+        importFoldersConcurrency: 2,
+        mapperRootDir: 'mapper',
+        mapperAssetsModuleDir: 'assets',
+        mapperUidFileName: 'uid-mapping.json',
+        mapperUrlFileName: 'url-mapping.json',
+        mapperSpaceUidFileName: 'space-uid-mapping.json',
+      },
+    },
+  } as unknown as ImportConfig;
+
+  it('should map basic importConfig fields to ImportSpacesOptions', () => {
+    const result = buildImportSpacesOptions(baseConfig, 'https://am.example.com');
+
+    expect(result.contentDir).to.equal('/tmp/content');
+    expect(result.assetManagementUrl).to.equal('https://am.example.com');
+    expect(result.org_uid).to.equal('org-123');
+    expect(result.apiKey).to.equal('stack-api-key');
+    expect(result.host).to.equal('https://api.contentstack.io/v3');
+    expect(result.sourceApiKey).to.equal('source-api-key');
+    expect(result.backupDir).to.equal('/tmp/backup');
+    expect(result.apiConcurrency).to.equal(5);
+    expect(result.uploadAssetsConcurrency).to.equal(3);
+    expect(result.importFoldersConcurrency).to.equal(2);
+  });
+
+  it('should leave targetDefaultSpaceUid and targetDefaultWorkspaceUid undefined when no overrides provided', () => {
+    const result = buildImportSpacesOptions(baseConfig, 'https://am.example.com');
+
+    expect(result.targetDefaultSpaceUid).to.be.undefined;
+    expect(result.targetDefaultWorkspaceUid).to.be.undefined;
+  });
+
+  it('should populate targetDefaultSpaceUid when provided via overrides', () => {
+    const result = buildImportSpacesOptions(baseConfig, 'https://am.example.com', {
+      targetDefaultSpaceUid: 'space-3-uid',
+    });
+
+    expect(result.targetDefaultSpaceUid).to.equal('space-3-uid');
+    expect(result.targetDefaultWorkspaceUid).to.be.undefined;
+  });
+
+  it('should populate both target default fields when provided via overrides', () => {
+    const result = buildImportSpacesOptions(baseConfig, 'https://am.example.com', {
+      targetDefaultSpaceUid: 'space-3-uid',
+      targetDefaultWorkspaceUid: 'ws-link-3',
+    });
+
+    expect(result.targetDefaultSpaceUid).to.equal('space-3-uid');
+    expect(result.targetDefaultWorkspaceUid).to.equal('ws-link-3');
+  });
+
+  it('should use org_uid empty string when importConfig.org_uid is undefined', () => {
+    const configWithoutOrg = { ...baseConfig, org_uid: undefined } as unknown as ImportConfig;
+    const result = buildImportSpacesOptions(configWithoutOrg, 'https://am.example.com');
+
+    expect(result.org_uid).to.equal('');
+  });
+
+  it('should prefer region.cma over host for the host field', () => {
+    const configWithRegion = {
+      ...baseConfig,
+      region: { cma: 'https://region.api.com' },
+      host: 'https://fallback.api.com',
+    } as unknown as ImportConfig;
+
+    const result = buildImportSpacesOptions(configWithRegion, 'https://am.example.com');
+
+    expect(result.host).to.equal('https://region.api.com');
+  });
+
+  it('should fall back to host when region.cma is absent', () => {
+    const configNoRegion = {
+      ...baseConfig,
+      region: undefined,
+      host: 'https://fallback.api.com',
+    } as unknown as ImportConfig;
+
+    const result = buildImportSpacesOptions(configNoRegion, 'https://am.example.com');
+
+    expect(result.host).to.equal('https://fallback.api.com');
+  });
+});
diff --git a/packages/contentstack-import/test/unit/utils/extension-helper.test.ts b/packages/contentstack-import/test/unit/utils/extension-helper.test.ts
index f99a8fd9a..805422f44 100644
--- a/packages/contentstack-import/test/unit/utils/extension-helper.test.ts
+++ b/packages/contentstack-import/test/unit/utils/extension-helper.test.ts
@@ -54,6 +54,11 @@ describe('Extension Helper', () => {
       webhooks: { dirName: 'webhooks', fileName: 'webhooks.json' },
       releases: { dirName: 'releases', fileName: 'releases.json', invalidKeys: ['uid'] },
       workflows: { dirName: 'workflows', fileName: 'workflows.json', invalidKeys: ['uid'] },
+      'publishing-rules': {
+        dirName: 'workflows',
+        fileName: 'publishing-rules.json',
+        invalidKeys: ['uid'],
+      },
       assets: {
         dirName: 'assets',
         assetBatchLimit: 10,
diff --git a/packages/contentstack-import/test/unit/utils/publishing-rules-helper.test.ts b/packages/contentstack-import/test/unit/utils/publishing-rules-helper.test.ts
new file mode 100644
index 000000000..1453b68eb
--- /dev/null
+++ b/packages/contentstack-import/test/unit/utils/publishing-rules-helper.test.ts
@@ -0,0 +1,57 @@
+import { expect } from 'chai';
+import { parseErrorPayload, isDuplicatePublishingRuleError } from '../../../src/utils/publishing-rules-helper';
+
+describe('publishing-rules-helper', () => {
+  describe('parseErrorPayload', () => {
+    it('returns the object when error has errors', () => {
+      const err = { errors: { name: 'taken' } };
+      expect(parseErrorPayload(err)).to.deep.equal({ errors: { name: 'taken' } });
+    });
+
+    it('parses JSON from message string', () => {
+      const err = { message: JSON.stringify({ error_message: 'already exists' }) };
+      expect(parseErrorPayload(err)).to.deep.equal({ error_message: 'already exists' });
+    });
+
+    it('returns null for invalid JSON in message', () => {
+      expect(parseErrorPayload({ message: 'not-json{' })).to.equal(null);
+    });
+
+    it('returns null for non-object', () => {
+      expect(parseErrorPayload(null)).to.equal(null);
+      expect(parseErrorPayload('x')).to.equal(null);
+    });
+
+    it('returns null when object has no errors or parseable message', () => {
+      expect(parseErrorPayload({ foo: 1 })).to.equal(null);
+    });
+  });
+
+  describe('isDuplicatePublishingRuleError', () => {
+    it('returns true when errors.name is set', () => {
+      expect(isDuplicatePublishingRuleError({ errors: { name: 'x' } }, {})).to.equal(true);
+    });
+
+    it('returns true when errors.publishing_rule.name is set', () => {
+      expect(isDuplicatePublishingRuleError({ errors: { 'publishing_rule.name': 'x' } }, {})).to.equal(true);
+    });
+
+    it('returns true when errors.publish_rule.name is set', () => {
+      expect(isDuplicatePublishingRuleError({ errors: { 'publish_rule.name': 'x' } }, {})).to.equal(true);
+    });
+
+    it('returns true when error_message matches duplicate wording', () => {
+      expect(isDuplicatePublishingRuleError({ error_message: 'Rule already exists' }, {})).to.equal(true);
+    });
+
+    it('reads errors from raw when parsed is null', () => {
+      const raw = { errors: { name: 'dup' } };
+      expect(isDuplicatePublishingRuleError(null, raw)).to.equal(true);
+    });
+
+    it('returns false when no duplicate signals', () => {
+      expect(isDuplicatePublishingRuleError({ errors: { other: 'x' } }, {})).to.equal(false);
+      expect(isDuplicatePublishingRuleError({ error_message: 'timeout' }, {})).to.equal(false);
+    });
+  });
+});
diff --git a/packages/contentstack-migration/package.json b/packages/contentstack-migration/package.json
index 0f9b7ae20..172f799ea 100644
--- a/packages/contentstack-migration/package.json
+++ b/packages/contentstack-migration/package.json
@@ -7,7 +7,6 @@
     "@contentstack/cli-command": "~2.0.0-beta.6",
     "@contentstack/cli-utilities": "~2.0.0-beta.7",
     "@oclif/core": "^4.3.0",
-    "@oclif/plugin-help": "^6.2.28",
     "async": "^3.2.6",
     "callsites": "^3.1.0",
     "cardinal": "^2.1.1",
@@ -22,7 +21,7 @@
     "@types/mocha": "^8.2.3",
     "@types/node": "^14.18.63",
     "chai": "^4.5.0",
-    "eslint": "^8.57.1",
+    "eslint": "^9.26.0",
     "eslint-config-oclif": "^6.0.62",
     "jsdoc-to-markdown": "^8.0.3",
     "mocha": "^10.8.2",
@@ -71,4 +70,4 @@
       "cm:stacks:migration": "MGRTN"
     }
   }
-}
\ No newline at end of file
+}
diff --git a/packages/contentstack-query-export/.env-example b/packages/contentstack-query-export/.env-example
new file mode 100644
index 000000000..a55f16b1d
--- /dev/null
+++ b/packages/contentstack-query-export/.env-example
@@ -0,0 +1 @@
+ENVIRONMENT=NON_PROD
\ No newline at end of file
diff --git a/packages/contentstack-query-export/.eslintignore b/packages/contentstack-query-export/.eslintignore
new file mode 100644
index 000000000..5e42c8d63
--- /dev/null
+++ b/packages/contentstack-query-export/.eslintignore
@@ -0,0 +1,23 @@
+node_modules
+.todo
+.env
+.dccache
+logs
+contents
+lerna-debug.log
+.DS_Store
+contentTest
+build
+_backup*
+oclif.manifest.json
+.vscode
+.nyc_output
+contentstack-cli-logs
+packages/**/package-lock.json
+.dccache
+yarn.lock
+contents-*
+*.http
+*.todo
+talisman_output.log
+snyk_output.log
\ No newline at end of file
diff --git a/packages/contentstack-query-export/.eslintrc b/packages/contentstack-query-export/.eslintrc
new file mode 100644
index 000000000..cb46553b0
--- /dev/null
+++ b/packages/contentstack-query-export/.eslintrc
@@ -0,0 +1,55 @@
+{
+    "env": {
+        "node": true
+    },
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+        "project": "tsconfig.json",
+        "sourceType": "module"
+    },
+    "extends": [
+        // "oclif",
+        "oclif-typescript",
+        "plugin:@typescript-eslint/recommended"
+    ],
+    "rules": {
+        "@typescript-eslint/no-unused-vars": [
+            "error",
+            {
+                "args": "none"
+            }
+        ],
+        "@typescript-eslint/prefer-namespace-keyword": "error",
+        "@typescript-eslint/quotes": [
+            "error",
+            "single",
+            {
+                "avoidEscape": true,
+                "allowTemplateLiterals": true
+            }
+        ],
+        "semi": "off",
+        "@typescript-eslint/type-annotation-spacing": "error",
+        "@typescript-eslint/no-redeclare": "off",
+        "eqeqeq": [
+            "error",
+            "smart"
+        ],
+        "id-match": "error",
+        "no-eval": "error",
+        "no-var": "error",
+        "quotes": "off",
+        "indent": "off",
+        "camelcase": "off",
+        "comma-dangle": "off",
+        "arrow-parens": "off",
+        "operator-linebreak": "off",
+        "object-curly-spacing": "off",
+        "node/no-missing-import": "off",
+        "padding-line-between-statements": "off",
+        "@typescript-eslint/ban-ts-ignore": "off",
+        "unicorn/no-abusive-eslint-disable": "off",
+        "unicorn/consistent-function-scoping": "off",
+        "@typescript-eslint/no-use-before-define": "off"
+    }
+}
\ No newline at end of file
diff --git a/packages/contentstack-query-export/.gitignore b/packages/contentstack-query-export/.gitignore
new file mode 100644
index 000000000..86eaed73e
--- /dev/null
+++ b/packages/contentstack-query-export/.gitignore
@@ -0,0 +1,20 @@
+*-debug.log
+*-error.log
+/.nyc_output
+/dist
+/lib
+/tmp
+/yarn.lock
+node_modules
+.DS_Store
+coverage
+./contents
+.vscode/
+/lib
+.env
+_backup_*
+contents/
+logs/
+oclif.manifest.json
+talisman_output.log
+snyk_output.log
diff --git a/packages/contentstack-query-export/.mocharc.json b/packages/contentstack-query-export/.mocharc.json
new file mode 100644
index 000000000..b90d7f028
--- /dev/null
+++ b/packages/contentstack-query-export/.mocharc.json
@@ -0,0 +1,12 @@
+{
+  "require": [
+    "test/helpers/init.js",
+    "ts-node/register",
+    "source-map-support/register"
+  ],
+  "watch-extensions": [
+    "ts"
+  ],
+  "recursive": true,
+  "timeout": 5000
+}
\ No newline at end of file
diff --git a/packages/contentstack-query-export/.nycrc.json b/packages/contentstack-query-export/.nycrc.json
new file mode 100644
index 000000000..2ffb9c510
--- /dev/null
+++ b/packages/contentstack-query-export/.nycrc.json
@@ -0,0 +1,5 @@
+{
+    "include": [
+        "lib/**/*.js"
+    ]
+}
\ No newline at end of file
diff --git a/packages/contentstack-query-export/.prettierignore b/packages/contentstack-query-export/.prettierignore
new file mode 100644
index 000000000..70988e213
--- /dev/null
+++ b/packages/contentstack-query-export/.prettierignore
@@ -0,0 +1 @@
+**/README.md
\ No newline at end of file
diff --git a/packages/contentstack-query-export/.prettierrc b/packages/contentstack-query-export/.prettierrc
new file mode 100644
index 000000000..ba93fc77d
--- /dev/null
+++ b/packages/contentstack-query-export/.prettierrc
@@ -0,0 +1,7 @@
+{
+    "semi": true,
+    "trailingComma": "all",
+    "singleQuote": true,
+    "printWidth": 120,
+    "tabWidth": 2
+}
\ No newline at end of file
diff --git a/packages/contentstack-query-export/.talismanrc b/packages/contentstack-query-export/.talismanrc
new file mode 100644
index 000000000..2ee647a7c
--- /dev/null
+++ b/packages/contentstack-query-export/.talismanrc
@@ -0,0 +1,14 @@
+fileignoreconfig:
+  - filename: package-lock.json
+    checksum: b4f6e41c55c3c7fa9d8b7ea903eb9bc85f27464306a428c97b7e96e86ffce5f7
+  - filename: skills/testing/SKILL.md
+    checksum: da9831797a5e6a4d2e6e846c3f6d2583d84008d2dfd454dd7effe2f897c43a7b
+  - filename: skills/framework/SKILL.md
+    checksum: 217cf9123bf9b62a4d9b0c891af8ba388173c601c782ed0fea432f6be7ef5e56
+  - filename: skills/contentstack-cli/SKILL.md
+    checksum: b42e3526fb902a31080824b776cc8e233646139ee0915d89c0925744d56d586f
+  - filename: skills/code-review/SKILL.md
+    checksum: 687efb830fb4a9fb2b2e6682db052771706ddd9b12dc9cec04943e3cade929b3
+  - filename: skills/dev-workflow/SKILL.md
+    checksum: 03434201e3aaaa9239aff2f97826d64ac4ca31467b77c07330ac4b608ee24939
+version: '1.0'
diff --git a/packages/contentstack-query-export/AGENTS.md b/packages/contentstack-query-export/AGENTS.md
new file mode 100644
index 000000000..a50993c38
--- /dev/null
+++ b/packages/contentstack-query-export/AGENTS.md
@@ -0,0 +1,45 @@
+# CLI export-query plugin – Agent guide
+
+**Universal entry point** for contributors and AI agents. Detailed conventions live in **`skills/*/SKILL.md`**.
+
+## What this repo is
+
+| Field | Detail |
+| --- | --- |
+| **Name:** | `@contentstack/cli-cm-export-query` ([repository](https://github.com/contentstack/cli)) |
+| **Purpose:** | OCLIF plugin for **query-based** stack export (`cm:stacks:export-query` / short `EXPRTQRY`); implements `QueryExporter` and related export flow. |
+| **Out of scope (if any):** | Other export/import plugins live in sibling packages; this repo is only the query-export plugin. |
+
+## Tech stack (at a glance)
+
+| Area | Details |
+| --- | --- |
+| **Language** | TypeScript **^4.9** (`tsconfig.json`); Node **>= 14** (`engines`) |
+| **Build** | `tsc -b` → `lib/`; `prepack` runs compile + `oclif manifest` + `oclif readme`; copies `src/config` → `lib/` |
+| **Tests** | Mocha + Chai + Sinon; **nyc** coverage; tests under `test/**/*.test.ts` (see [skills/testing/SKILL.md](skills/testing/SKILL.md)) |
+| **Lint / coverage** | ESLint `src/**/*.ts`; nyc in `npm test` |
+| **Other** | OCLIF v4, Husky |
+
+## Commands (quick reference)
+
+| Command type | Command |
+| --- | --- |
+| **Build** | `npm run build` |
+| **Test** | `npm test` |
+| **Lint** | `npm run lint` |
+
+CI: [.github/workflows/unit-test.yml](.github/workflows/unit-test.yml); also `release.yml`, `sca-scan.yml`, `policy-scan.yml` under [.github/workflows/](.github/workflows/).
+
+## Where the documentation lives: skills
+
+| Skill | Path | What it covers |
+| --- | --- | --- |
+| Development workflow | [skills/dev-workflow/SKILL.md](skills/dev-workflow/SKILL.md) | CI, branches, Husky, PR expectations |
+| Contentstack CLI | [skills/contentstack-cli/SKILL.md](skills/contentstack-cli/SKILL.md) | Commands, `QueryExporter`, APIs |
+| Framework | [skills/framework/SKILL.md](skills/framework/SKILL.md) | Config, logging, errors, utilities |
+| Testing | [skills/testing/SKILL.md](skills/testing/SKILL.md) | Mocha/Chai/Sinon, nyc, TDD |
+| Code review | [skills/code-review/SKILL.md](skills/code-review/SKILL.md) | PR checklist |
+
+## Using Cursor (optional)
+
+If you use **Cursor**, [.cursor/rules/README.md](.cursor/rules/README.md) only points to **`AGENTS.md`**—same docs as everyone else.
diff --git a/packages/contentstack-query-export/LICENSE b/packages/contentstack-query-export/LICENSE
new file mode 100644
index 000000000..aff1142ee
--- /dev/null
+++ b/packages/contentstack-query-export/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Contentstack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/packages/contentstack-query-export/README.md b/packages/contentstack-query-export/README.md
new file mode 100644
index 000000000..137aa8012
--- /dev/null
+++ b/packages/contentstack-query-export/README.md
@@ -0,0 +1,108 @@
+# Contentstack CLI Query Export Plugin
+
+A powerful CLI plugin for Contentstack that enables query-based content export with intelligent dependency resolution and asset reference detection.
+
+## Overview
+
+This plugin extends the Contentstack CLI to export content based on custom queries, automatically resolving dependencies between content types, global fields, extensions, and taxonomies. It intelligently detects and exports referenced assets to ensure complete content portability.
+
+## Features
+
+- 🔍 **Query-based Export**: Export content using custom queries instead of entire content types
+- 🔗 **Dependency Resolution**: Automatically resolve and export dependencies (global fields, extensions, taxonomies)
+- 🖼️ **Asset Reference Detection**: Intelligent detection of asset references in various formats
+- 📁 **Organized Output**: Well-structured export with separate folders for each module
+- ⚙️ **Configurable**: Support for external config files and flexible options
+- 🌐 **Multi-locale Support**: Export content across different locales
+- 📊 **Export Metadata**: Comprehensive metadata tracking for export operations
+
+## Installation
+
+```bash
+# Install as a Contentstack CLI plugin
+npm install -g @contentstack/cli-cm-export-query
+
+# Or install locally
+npm install @contentstack/cli-cm-export-query
+```
+
+## Usage
+
+### Basic Export
+
+```bash
+# Export using management token alias
+csdx cm:stacks:export-query -a <alias> -q "{'title': {'$exists': true}}"
+
+# Export using API key and management token
+csdx cm:stacks:export-query --stack-api-key <api-key> -A <management-token> -q "{'title': {'$exists': true}}"
+```
+
+### Command Options
+
+| Flag | Description | Required |
+|------|-------------|----------|
+| `-a, --alias` | Management token alias | Yes (or use -A) |
+| `-A, --management-token` | Management token | Yes (or use -a) |
+| `--stack-api-key` | Stack API key | Yes |
+| `-q, --query` | Query for content export | Yes |
+| `-d, --data-dir` | Export directory path | No |
+| `--branch` | Branch name | No |
+| `--skip-references` | Skip reference resolution | No |
+| `--skip-dependencies` | Skip dependency export | No |
+| `--secured-assets` | Include secured assets | No |
+| `--config` | External config file path | No |
+
+### Query Examples
+
+**Basic Content Query:**
+```bash
+csdx cm:stacks:export-query -a prod -q "{'title': {'$regex': 'blog'}}"
+```
+
+**Date Range Query:**
+```bash
+csdx cm:stacks:export-query -a prod -q "{'updated_at': {'$gte': '2024-01-01'}}"
+```
+
+**Complex Query:**
+```bash
+csdx cm:stacks:export-query -a prod -q "{'$and': [{'title': {'$exists': true}}, {'tags': {'$in': ['featured']}}]}"
+```
+
+## Configuration
+
+### Default Configuration
+
+The plugin includes a default configuration file at `src/config/export-defaults.json`:
+
+```json
+{
+  "skipReferences": false,
+  "skipDependencies": false,
+  "securedAssets": false,
+  "includeGlobalFieldSchema": true,
+  "includePublishDetails": true,
+  "includeDimension": false,
+  "fetchConcurrency": 5,
+  "writeConcurrency": 5,
+  "batchSize": 100
+}
+```
+
+### External Configuration
+
+Create a custom config file and pass it using the `--config` flag:
+
+```json
+{
+  "skipReferences": true,
+  "batchSize": 50,
+  "fetchConcurrency": 3,
+  "securedAssets": true
+}
+```
+
+```bash
+csdx cm:stacks:export-query -a prod -q "{'title': {'$exists': true}}" --config ./my-config.json
+```
diff --git a/packages/contentstack-query-export/SECURITY.md b/packages/contentstack-query-export/SECURITY.md
new file mode 100644
index 000000000..1f44e3424
--- /dev/null
+++ b/packages/contentstack-query-export/SECURITY.md
@@ -0,0 +1,27 @@
+## Security
+
+Contentstack takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations.
+
+If you believe you have found a security vulnerability in any Contentstack-owned repository, please report it to us as described below.
+
+## Reporting Security Issues
+
+**Please do not report security vulnerabilities through public GitHub issues.**
+
+Send email to [security@contentstack.com](mailto:security@contentstack.com).
+
+You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message.
+
+Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
+
+- Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
+- Full paths of source file(s) related to the manifestation of the issue
+- The location of the affected source code (tag/branch/commit or direct URL)
+- Any special configuration required to reproduce the issue
+- Step-by-step instructions to reproduce the issue
+- Proof-of-concept or exploit code (if possible)
+- Impact of the issue, including how an attacker might exploit the issue
+
+This information will help us triage your report more quickly.
+
+[https://www.contentstack.com/trust/](https://www.contentstack.com/trust/)
diff --git a/packages/contentstack-query-export/bin/dev.cmd b/packages/contentstack-query-export/bin/dev.cmd
new file mode 100644
index 000000000..077b57ae7
--- /dev/null
+++ b/packages/contentstack-query-export/bin/dev.cmd
@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\dev" %*
\ No newline at end of file
diff --git a/packages/contentstack-query-export/bin/dev.js b/packages/contentstack-query-export/bin/dev.js
new file mode 100755
index 000000000..b2e3af809
--- /dev/null
+++ b/packages/contentstack-query-export/bin/dev.js
@@ -0,0 +1,6 @@
+#!/usr/bin/env node_modules/.bin/ts-node
+// eslint-disable-next-line node/shebang, unicorn/prefer-top-level-await
+(async () => {
+  const oclif = await import('@oclif/core');
+  await oclif.execute({ development: true, dir: __dirname });
+})();
diff --git a/packages/contentstack-query-export/bin/run.cmd b/packages/contentstack-query-export/bin/run.cmd
new file mode 100644
index 000000000..968fc3075
--- /dev/null
+++ b/packages/contentstack-query-export/bin/run.cmd
@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*
diff --git a/packages/contentstack-query-export/bin/run.js b/packages/contentstack-query-export/bin/run.js
new file mode 100755
index 000000000..8baf30239
--- /dev/null
+++ b/packages/contentstack-query-export/bin/run.js
@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+// eslint-disable-next-line unicorn/prefer-top-level-await
+(async () => {
+  const oclif = await import('@oclif/core');
+  await oclif.execute({ development: false, dir: __dirname });
+})();
diff --git a/packages/contentstack-query-export/messages/index.json b/packages/contentstack-query-export/messages/index.json
new file mode 100644
index 000000000..21a72c884
--- /dev/null
+++ b/packages/contentstack-query-export/messages/index.json
@@ -0,0 +1,75 @@
+{
+  "ASSET_EXPORT_COMPLETE": "Asset export process completed successfully",
+  "ASSET_FOLDERS_EXPORT_COMPLETE": "Asset folder structure exported successfully",
+  "ASSET_METADATA_EXPORT_COMPLETE": "Asset metadata exported successfully",
+  "ASSET_VERSIONED_METADATA_EXPORT_COMPLETE": "Versioned asset metadata exported successfully",
+  "ASSET_DOWNLOAD_COMPLETE": "Asset download completed successfully",
+  "ASSET_DOWNLOAD_SUCCESS": "Asset '%s' (UID: %s) downloaded successfully",
+  "ASSET_DOWNLOAD_FAILED": "Failed to download asset '%s' (UID: %s)",
+  "ASSET_WRITE_FAILED": "Failed to write asset file '%s' (UID: %s)",
+  "ASSET_QUERY_FAILED": "Failed to query asset data from the API",
+  "ASSET_VERSIONED_QUERY_FAILED": "Failed to query versioned asset data from the API",
+  "ASSET_COUNT_QUERY_FAILED": "Failed to retrieve total asset count",
+
+  "CONTENT_TYPE_EXPORT_COMPLETE": "Content types exported successfully",
+  "CONTENT_TYPE_NO_TYPES": "No content types found",
+  "CONTENT_TYPE_EXPORT_FAILED": "Failed to export content types",
+  "CONTENT_TYPE_NO_TYPES_RETURNED": "API returned no content types for the given query",
+
+  "ENVIRONMENT_EXPORT_COMPLETE": "Successfully exported %s environment(s)",
+  "ENVIRONMENT_EXPORT_SUCCESS": "Environment '%s' exported successfully",
+  "ENVIRONMENT_NOT_FOUND": "No environments found in the current stack",
+
+  "EXTENSION_EXPORT_COMPLETE": "Successfully exported %s extension(s)",
+  "EXTENSION_EXPORT_SUCCESS": "Extension '%s' exported successfully",
+  "EXTENSION_NOT_FOUND": "No extensions found in the current stack",
+
+  "GLOBAL_FIELDS_EXPORT_COMPLETE": "Successfully exported %s global field(s)",
+
+  "LABELS_EXPORT_COMPLETE": "Successfully exported %s label(s)",
+  "LABEL_EXPORT_SUCCESS": "Label '%s' exported successfully",
+  "LABELS_NOT_FOUND": "No labels found in the current stack",
+
+  "LOCALES_EXPORT_COMPLETE": "Successfully exported %s locale(s) including %s master locale(s)",
+
+  "TAXONOMY_EXPORT_COMPLETE": "Successfully exported %s taxonomy entries",
+  "TAXONOMY_EXPORT_SUCCESS": "Taxonomy '%s' exported successfully",
+  "TAXONOMY_NOT_FOUND": "No taxonomies found in the current stack",
+
+  "WEBHOOK_EXPORT_COMPLETE": "Successfully exported %s webhook(s)",
+  "WEBHOOK_EXPORT_SUCCESS": "Webhook '%s' exported successfully",
+  "WEBHOOK_NOT_FOUND": "No webhooks found in the current stack",
+
+  "WORKFLOW_EXPORT_COMPLETE": "Successfully exported %s workflow(s)",
+  "WORKFLOW_EXPORT_SUCCESS": "Workflow '%s' exported successfully",
+  "WORKFLOW_NOT_FOUND": "No workflows found in the current stack",
+
+  "PERSONALIZE_URL_NOT_SET": "Cannot export Personalize project: URL not configured",
+  "PERSONALIZE_SKIPPING_WITH_MANAGEMENT_TOKEN": "Skipping Personalize project export: Management token not supported",
+  "PERSONALIZE_MODULE_NOT_IMPLEMENTED": "Module '%s' implementation not found",
+  "PERSONALIZE_NOT_ENABLED": "Personalize feature is not enabled for this organization",
+
+  "MARKETPLACE_APPS_EXPORT_COMPLETE": "Successfully exported %s marketplace app(s)",
+  "MARKETPLACE_APP_CONFIG_EXPORT": "Exporting configuration for app '%s'",
+  "MARKETPLACE_APP_CONFIG_SUCCESS": "Successfully exported configuration for app '%s'",
+  "MARKETPLACE_APP_EXPORT_SUCCESS": "Successfully exported app '%s'",
+  "MARKETPLACE_APPS_NOT_FOUND": "No marketplace apps found in the current stack",
+  "MARKETPLACE_APP_CONFIG_EXPORT_FAILED": "Failed to export configuration for app '%s'",
+  "MARKETPLACE_APP_MANIFEST_EXPORT_FAILED": "Failed to export manifest for app '%s'",
+
+  "COMPOSABLE_STUDIO_EXPORT_START": "Starting Studio project export...",
+  "COMPOSABLE_STUDIO_NOT_FOUND": "No Studio project found for this stack",
+  "COMPOSABLE_STUDIO_EXPORT_COMPLETE": "Successfully exported Studio project '%s'",
+  "COMPOSABLE_STUDIO_EXPORT_FAILED": "Failed to export Studio project: %s",
+  "COMPOSABLE_STUDIO_AUTH_REQUIRED": "To export Studio projects, you must be logged in",
+
+  "ENTRIES_EXPORT_COMPLETE": "Successfully exported entries (Content Type: %s, Locale: %s)",
+  "ENTRIES_EXPORT_SUCCESS": "All entries exported successfully",
+  "ENTRIES_VERSIONED_EXPORT_SUCCESS": "Successfully exported versioned entry (Content Type: %s, UID: %s, Locale: %s)",
+  "ENTRIES_EXPORT_VERSIONS_FAILED": "Failed to export versions for content type '%s' (UID: %s)",
+
+  "BRANCH_EXPORT_FAILED": "Failed to export contents from branch (UID: %s)",
+
+  "ROLES_NO_CUSTOM_ROLES": "No custom roles found in the current stack",
+  "ROLES_EXPORTING_ROLE": "Exporting role '%s'"
+}
diff --git a/packages/contentstack-query-export/package.json b/packages/contentstack-query-export/package.json
new file mode 100644
index 000000000..146805e7e
--- /dev/null
+++ b/packages/contentstack-query-export/package.json
@@ -0,0 +1,101 @@
+{
+  "name": "@contentstack/cli-cm-export-query",
+  "description": "Contentstack CLI plugin to export content from stack",
+  "version": "2.0.0-beta.0",
+  "author": "Contentstack",
+  "bugs": "https://github.com/contentstack/cli/issues",
+  "dependencies": {
+    "@contentstack/cli-cm-export": "~2.0.0-beta.16",
+    "@contentstack/cli-command": "~2.0.0-beta.6",
+    "@contentstack/cli-utilities": "~2.0.0-beta.7",
+    "@oclif/core": "^4.10.5",
+    "async": "^3.2.6",
+    "big-json": "^3.2.0",
+    "bluebird": "^3.7.2",
+    "lodash": "^4.18.1",
+    "merge": "^2.1.1",
+    "mkdirp": "^1.0.4",
+    "progress-stream": "^2.0.0",
+    "promise-limit": "^2.7.0",
+    "tslib": "^2.8.1",
+    "winston": "^3.19.0"
+  },
+  "overrides": {
+    "brace-expansion": "^5.0.5"
+  },
+  "devDependencies": {
+    "@contentstack/cli-dev-dependencies": "~1.3.1",
+    "@oclif/plugin-help": "^6.2.44",
+    "@oclif/test": "^4.1.18",
+    "@types/big-json": "^3.2.5",
+    "@types/chai": "^4.3.20",
+    "@types/mkdirp": "^1.0.2",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^20.19.39",
+    "@types/progress-stream": "^2.0.5",
+    "@types/sinon": "^17.0.4",
+    "chai": "^4.5.0",
+    "dotenv": "^16.6.1",
+    "dotenv-expand": "^9.0.0",
+    "eslint": "^8.57.1",
+    "eslint-config-oclif": "^6.0.157",
+    "husky": "^9.1.7",
+    "mocha": "10.8.2",
+    "nyc": "^15.1.0",
+    "oclif": "^4.17.46",
+    "sinon": "^17.0.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^4.9.5"
+  },
+  "scripts": {
+    "build": "pnpm compile && pnpm copy-config && oclif manifest && oclif readme",
+    "clean": "rm -rf ./lib ./node_modules tsconfig.tsbuildinfo",
+    "compile": "tsc -b tsconfig.json",
+    "postpack": "rm -f oclif.manifest.json",
+    "copy-config": "cp -r src/config lib/",
+    "prepack": "pnpm compile && pnpm copy-config && oclif manifest && oclif readme",
+    "version": "oclif readme && git add README.md",
+    "test:report": "tsc -p test && nyc --reporter=lcov --extension .ts mocha --forbid-only \"test/**/*.test.ts\"",
+    "pretest": "tsc -p test",
+    "test": "nyc --extension .ts mocha --forbid-only \"test/**/*.test.ts\"",
+    "posttest": "npm run lint",
+    "lint": "eslint src/**/*.ts",
+    "format": "eslint src/**/*.ts --fix",
+    "test:integration": "INTEGRATION_TEST=true mocha --config ./test/.mocharc.js --forbid-only \"test/run.test.js\"",
+    "test:integration:report": "INTEGRATION_TEST=true nyc --extension .js mocha --forbid-only \"test/run.test.js\"",
+    "test:unit": "mocha --forbid-only \"test/unit/**/*.test.ts\"",
+    "test:unit:report": "nyc --reporter=text --extension .ts mocha --forbid-only \"test/unit/**/*.test.ts\""
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "/lib",
+    "/messages",
+    "/npm-shrinkwrap.json",
+    "/oclif.manifest.json"
+  ],
+  "homepage": "https://github.com/contentstack/cli",
+  "keywords": [
+    "contentstack",
+    "cli",
+    "plugin"
+  ],
+  "license": "MIT",
+  "main": "./lib/commands/cm/stacks/export-query.js",
+  "oclif": {
+    "commands": "./lib/commands",
+    "bin": "csdx",
+    "devPlugins": [
+      "@oclif/plugin-help"
+    ],
+    "repositoryPrefix": "<%- repo %>/blob/main/packages/contentstack-query-export/<%- commandPath %>"
+  },
+  "csdxConfig": {
+    "shortCommandName": {
+      "cm:stacks:export-query": "EXPRTQRY",
+      "cm:export:query": "EXPRTQRY"
+    }
+  },
+  "repository": "https://github.com/contentstack/cli"
+}
\ No newline at end of file
diff --git a/packages/contentstack-query-export/skills/README.md b/packages/contentstack-query-export/skills/README.md
new file mode 100644
index 000000000..781157144
--- /dev/null
+++ b/packages/contentstack-query-export/skills/README.md
@@ -0,0 +1,3 @@
+# Skills – CLI export-query
+
+Source of truth for detailed guidance. Read [AGENTS.md](../AGENTS.md) for the skill index, then open the `SKILL.md` that matches your task. Each folder contains `SKILL.md` with YAML frontmatter (`name`, `description`).
diff --git a/packages/contentstack-query-export/skills/code-review/SKILL.md b/packages/contentstack-query-export/skills/code-review/SKILL.md
new file mode 100644
index 000000000..ad0a78e21
--- /dev/null
+++ b/packages/contentstack-query-export/skills/code-review/SKILL.md
@@ -0,0 +1,204 @@
+---
+name: code-review
+description: PR review checklist for this repo and similar CLI plugins. Use when reviewing changes to export-query, core, or utils.
+---
+
+# Code Review Skill
+
+Use the **Quick checklist template** for a short PR paste. Numbered sections **1**–**7** and **Review checklist summary** below are the full deep review for **`@contentstack/cli-cm-export-query`** and related CLI work.
+
+## Quick checklist template
+
+```markdown
+## Security Review
+- [ ] No hardcoded secrets
+- [ ] Input validation present
+- [ ] Error handling secure
+
+## Correctness Review  
+- [ ] Logic correctly implemented
+- [ ] Edge cases handled
+- [ ] Error scenarios covered
+
+## Architecture Review
+- [ ] Proper code organization
+- [ ] Design patterns followed
+- [ ] Good modularity
+
+## Performance Review
+- [ ] Efficient implementation
+- [ ] Resource management
+- [ ] Appropriate concurrency
+
+## Testing Review
+- [ ] Adequate tests for behavior changed
+- [ ] Quality tests
+- [ ] Test-first used where practical for new behavior
+
+## Code Conventions
+- [ ] TypeScript standards
+- [ ] Code style consistent
+- [ ] Documentation adequate
+```
+
+## 1. Security Review
+
+### Authentication & Authorization
+- [ ] No hardcoded API keys, tokens, or credentials
+- [ ] Sensitive data not logged to console or files
+- [ ] Proper token validation and expiration handling
+- [ ] Environment variables used for secrets
+
+### Input Validation
+- [ ] All user inputs validated and sanitized
+- [ ] Command flags properly validated
+- [ ] File paths sanitized to prevent directory traversal
+- [ ] API responses validated before processing
+
+### Error Handling
+- [ ] Errors don't expose sensitive information
+- [ ] Stack traces filtered in production
+- [ ] Proper error logging without secrets
+
+## 2. Correctness Review
+
+### Logic Validation
+- [ ] Business logic correctly implemented
+- [ ] Edge cases handled appropriately
+- [ ] Null/undefined checks in place
+- [ ] Async operations properly awaited
+
+### Error Scenarios
+- [ ] Network failures handled gracefully
+- [ ] Rate limiting respected and handled
+- [ ] Partial failures in batch operations managed
+- [ ] Retry logic implemented correctly
+
+### Data Integrity
+- [ ] Data transformations are reversible where needed
+- [ ] Batch operations maintain consistency
+- [ ] Rollback mechanisms for critical operations
+- [ ] Proper validation before destructive operations
+
+## 3. Architecture Review
+
+### Code Organization
+- [ ] Proper separation of concerns (Commands → Services → Utils)
+- [ ] Single responsibility principle followed
+- [ ] Dependencies injected, not hardcoded
+- [ ] Interfaces used for abstractions
+
+### Design Patterns
+- [ ] Consistent error handling patterns
+- [ ] Proper use of async/await
+- [ ] Service layer properly abstracted
+- [ ] Configuration management centralized
+
+### Modularity
+- [ ] Functions are focused and testable
+- [ ] Classes have clear responsibilities
+- [ ] Modules are loosely coupled
+- [ ] Common functionality extracted to utilities
+
+## 4. Performance Review
+
+### Efficiency
+- [ ] Unnecessary API calls eliminated
+- [ ] Export/query work batched or paginated where the Management API requires it
+- [ ] Proper pagination implemented when listing large result sets
+- [ ] Rate limiting respected
+
+### Resource Management
+- [ ] Memory usage optimized for large datasets
+- [ ] File handles properly closed
+- [ ] Network connections cleaned up
+- [ ] No memory leaks in long-running operations
+
+### Concurrency
+- [ ] Appropriate concurrency limits set
+- [ ] Race conditions avoided
+- [ ] Deadlocks prevented
+- [ ] Resource contention minimized
+
+## 5. Testing Review
+
+### Test Coverage
+- [ ] All new/modified code has tests
+- [ ] Both success and failure paths tested
+- [ ] Edge cases covered
+- [ ] Integration tests for complex workflows
+
+### Test Quality
+- [ ] Tests are focused and readable
+- [ ] Proper mocking of external dependencies
+- [ ] No real API calls in tests
+- [ ] Test data is realistic and maintainable
+
+### TDD / test discipline
+- [ ] New behavior covered by tests where practical (test-first preferred, not mandatory for refactors/docs)
+- [ ] Tests fail appropriately when code is broken
+- [ ] Tests are independent and can run in any order
+- [ ] No test.skip or .only in committed code
+
+## 6. CLI-Specific Review
+
+### OCLIF Command Structure
+- [ ] Extends appropriate base command class
+- [ ] Proper flag definitions with validation
+- [ ] Clear command description and examples
+- [ ] Appropriate error handling with user-friendly messages
+
+### User Experience
+- [ ] Progress indicators for long operations
+- [ ] Clear success/failure messaging
+- [ ] Proper use of colors and formatting
+- [ ] Confirmation prompts for destructive actions
+
+### Command patterns
+- [ ] Input validation before processing
+- [ ] Heavy logic delegated to `src/core/` and `src/utils/` (not the command class)
+- [ ] Proper logging for debugging
+- [ ] Graceful handling of interruptions
+
+## 7. Contentstack Integration Review
+
+### API Usage
+- [ ] Proper authentication using CLI utilities
+- [ ] Rate limiting respected (10 req/sec for Management API)
+- [ ] Appropriate error handling for API-specific errors
+- [ ] Retry logic for transient failures
+
+### Query export behavior
+- [ ] Query parsing and flags behave as documented
+- [ ] Dependency / reference / asset handling respects `skip-*` flags
+- [ ] Failures surface clearly to the user (no silent drops)
+- [ ] Logging useful for support without leaking secrets
+
+### Environment Management
+- [ ] Environment validation before operations
+- [ ] Cross-environment operations handled safely
+- [ ] Proper handling of environment-specific configurations
+- [ ] Content type validation
+
+## Review Checklist Summary
+
+### Before Approving
+- [ ] All critical issues resolved
+- [ ] Tests pass; coverage reasonable for the change (~80% repo-wide is aspirational)
+- [ ] Security concerns addressed
+- [ ] Performance implications considered
+- [ ] Documentation updated if needed
+- [ ] Breaking changes properly communicated
+
+### Review Quality
+- [ ] Code thoroughly examined, not just skimmed
+- [ ] Constructive feedback provided
+- [ ] Questions asked for unclear implementations
+- [ ] Best practices enforced consistently
+- [ ] Knowledge shared through comments
+
+### Post-Review
+- [ ] Appropriate merge strategy selected
+- [ ] Deployment considerations discussed
+- [ ] Team notified of significant changes
+- [ ] Follow-up tasks created if needed
\ No newline at end of file
diff --git a/packages/contentstack-query-export/skills/contentstack-cli/SKILL.md b/packages/contentstack-query-export/skills/contentstack-cli/SKILL.md
new file mode 100644
index 000000000..f78d3ee40
--- /dev/null
+++ b/packages/contentstack-query-export/skills/contentstack-cli/SKILL.md
@@ -0,0 +1,121 @@
+---
+name: contentstack-cli
+description: Contentstack CLI query-export plugin — OCLIF command, QueryExporter, cli-utilities, and export behavior. Use for commands, core export logic, utils, and API usage in this repo.
+---
+
+# Contentstack CLI — query export
+
+Guidance for **`@contentstack/cli-cm-export-query`**: query-driven export with dependency and asset handling.
+
+## This package
+
+- **Command:** `ExportQueryCommand` in `src/commands/cm/stacks/export-query.ts` extends **`Command`** from **`@contentstack/cli-command`**.
+- **Orchestration:** **`QueryExporter`** and **`ModuleExporter`** in **`src/core/`**.
+- **Helpers:** Query parsing, config, dependencies, assets, branches under **`src/utils/`**.
+- **Integration:** **`@contentstack/cli-cm-export`**, **`@contentstack/cli-utilities`**, **`@oclif/core`** (transitive / manifest).
+
+## Practices
+
+- Authenticate and build the management client via **`@contentstack/cli-utilities`**; never log secrets.
+- Keep **`run()`** thin; delegate to **`QueryExporter`** and existing utils.
+- Respect rate limits and handle **429** / transient errors when adding API calls.
+- Tests: mock SDK and file I/O; no real stack access in unit tests.
+
+## Repository layout
+
+| Area | Role |
+|------|------|
+| `src/commands/cm/stacks/export-query.ts` | CLI entry: flags, config setup, `QueryExporter` |
+| `src/core/query-executor.ts` | `QueryExporter` — main export pipeline |
+| `src/core/module-exporter.ts` | `ModuleExporter` — module export details |
+| `src/utils/` | Query parser, config, branches, dependencies, assets, files, logger |
+| `src/types/index.ts` | Shared types (e.g. `QueryExportConfig`, `Modules`) |
+| `src/config/` | Defaults (copied to `lib/` on build) |
+
+There is **no** `src/services/` directory in this repo.
+
+## Command pattern
+
+Use **`@contentstack/cli-command`** and **`@contentstack/cli-utilities`**:
+
+```typescript
+import { Command } from '@contentstack/cli-command';
+import {
+  flags,
+  FlagInput,
+  managementSDKClient,
+  log,
+  handleAndLogError,
+} from '@contentstack/cli-utilities';
+import { QueryExporter } from '../../../core/query-executor';
+
+export default class ExportQueryCommand extends Command {
+  static description = 'Export content from a stack using query-based filtering';
+
+  static flags: FlagInput = {
+    query: flags.string({
+      required: true,
+      description: 'Query as JSON string or file path',
+    }),
+    alias: flags.string({ char: 'a', description: 'Management token alias' }),
+    // ...see export-query.ts for full flags
+  };
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(ExportQueryCommand);
+    // setupQueryExportConfig(flags), managementSDKClient(...), then:
+    // const exporter = new QueryExporter(client, exportQueryConfig);
+    // await exporter.execute();
+  }
+}
+```
+
+### Conventions
+
+- Validate required inputs early (`query`, stack credentials).
+- Use **`log`** with export **context** objects for structured messages.
+- Use **`handleAndLogError`** for consistent error reporting where the codebase already does.
+
+## Export pipeline (conceptual)
+
+1. **Parse** query via **`QueryParser`** (JSON string or path to JSON file).
+2. **Export** general and queried modules (aligned with **`@contentstack/cli-cm-export`**).
+3. **Resolve** content types, references, and assets unless disabled (`skip-references`, `skip-dependencies`, `secured-assets`).
+
+When extending behavior, prefer new methods on **`QueryExporter`** / **`ModuleExporter`** or focused utils under **`src/utils/`**.
+
+## Authentication and secrets
+
+- Resolve tokens through CLI utilities and command flags; do not print management tokens or API keys.
+- Do not write secrets into export directories.
+
+## API and rate limits
+
+- Contentstack APIs are rate-limited; use delays or backoff on **429** when introducing new call patterns.
+- In tests, stub **`managementSDKClient`**, stack client methods, and **`fsUtil`** as the existing unit tests do.
+
+---
+
+## Other CLI plugins (context)
+
+Other Contentstack CLI packages sometimes use **`BaseBulkCommand`**, batch processors, or JSON logs under `bulk-operation/`. **This query-export plugin does not use those patterns.**
+
+### Rate limit sketch (generic)
+
+```typescript
+class RateLimiter {
+  private lastRequest = 0;
+  private readonly minIntervalMs = 100; // order-of-magnitude; tune per API guidance
+
+  async wait(): Promise<void> {
+    const now = Date.now();
+    const elapsed = now - this.lastRequest;
+    if (elapsed < this.minIntervalMs) {
+      await new Promise((r) => setTimeout(r, this.minIntervalMs - elapsed));
+    }
+    this.lastRequest = Date.now();
+  }
+}
+```
+
+Adapt to whatever **`@contentstack/cli-utilities`** or **`@contentstack/cli-cm-export`** already provides before adding parallel limiters.
diff --git a/packages/contentstack-query-export/skills/dev-workflow/SKILL.md b/packages/contentstack-query-export/skills/dev-workflow/SKILL.md
new file mode 100644
index 000000000..2845935ee
--- /dev/null
+++ b/packages/contentstack-query-export/skills/dev-workflow/SKILL.md
@@ -0,0 +1,35 @@
+---
+name: dev-workflow
+description: CI, Husky hooks, branch and PR expectations for the cli-cm-export-query plugin repo.
+---
+
+# Development workflow – CLI export-query
+
+## When to use
+
+- Running builds/tests before a PR
+- Understanding which GitHub Actions run on this package
+- Husky / pre-commit expectations
+
+## Commands
+
+| Command | Purpose |
+| --- | --- |
+| `npm run build` | Clean, install, compile, copy `src/config` → `lib/` |
+| `npm test` | `pretest` compiles tests; nyc + mocha `test/**/*.test.ts` |
+| `npm run test:unit` | Mocha `test/unit/**/*.test.ts` only |
+| `npm run lint` | ESLint `src/**/*.ts` |
+| `npm run prepack` | Compile + OCLIF manifest/readme + config copy (release path) |
+
+## CI
+
+Workflows under [`.github/workflows/`](../../../.github/workflows/): e.g. `unit-test.yml`, `release.yml`, `sca-scan.yml`, `policy-scan.yml`.
+
+## Git hooks
+
+- `prepare` runs Husky setup (see `package.json`); hooks live under [`.husky/`](../../../.husky/) when configured.
+
+## PR expectations
+
+- Tests and lint pass; no `describe.only` / `it.only` (`--forbid-only` in test scripts).
+- Coordinate with [testing](../testing/SKILL.md) and [code-review](../code-review/SKILL.md).
diff --git a/packages/contentstack-query-export/skills/framework/SKILL.md b/packages/contentstack-query-export/skills/framework/SKILL.md
new file mode 100644
index 000000000..6c75b92c4
--- /dev/null
+++ b/packages/contentstack-query-export/skills/framework/SKILL.md
@@ -0,0 +1,195 @@
+---
+name: framework
+description: Utilities, configuration, logging, and error patterns for @contentstack/cli-cm-export-query. Use when working in src/utils/, config, or shared helpers — align with @contentstack/cli-utilities where possible.
+---
+
+# Framework Patterns
+
+Core utilities, configuration, logging, and error-handling patterns for **`@contentstack/cli-cm-export-query`** (and similar CLI plugins). Prefer matching patterns already in **`src/utils/`** and **`@contentstack/cli-utilities`** before introducing new abstractions.
+
+## Configuration Management
+
+```typescript
+export interface AppConfig {
+  contentstack: { apiKey: string; authToken: string; region: string; };
+  batch: { defaultSize: number; maxConcurrency: number; retryAttempts: number; };
+  logging: { level: string; format: string; };
+}
+
+export class ConfigBuilder {
+  static build(): AppConfig {
+    return {
+      contentstack: { apiKey: process.env.CONTENTSTACK_API_KEY!, authToken: process.env.CONTENTSTACK_AUTH_TOKEN!, region: process.env.CONTENTSTACK_REGION || 'us' },
+      batch: { defaultSize: parseInt(process.env.BATCH_SIZE || '10'), maxConcurrency: parseInt(process.env.MAX_CONCURRENCY || '3'), retryAttempts: parseInt(process.env.RETRY_ATTEMPTS || '3') },
+      logging: { level: process.env.LOG_LEVEL || 'info', format: process.env.LOG_FORMAT || 'json' }
+    };
+  }
+  static validate(config: AppConfig): void {
+    if (!config.contentstack.apiKey) throw new Error('CONTENTSTACK_API_KEY is required');
+    if (!config.contentstack.authToken) throw new Error('CONTENTSTACK_AUTH_TOKEN is required');
+  }
+}
+```
+
+## Logging Framework
+
+```typescript
+export interface Logger { debug(message: string, meta?: object): void; info(message: string, meta?: object): void; warn(message: string, meta?: object): void; error(message: string, meta?: object): void; }
+
+export class ConsoleLogger implements Logger {
+  constructor(private level: string = 'info') {}
+  debug(message: string, meta?: object): void { if (this.shouldLog('debug')) console.debug(this.format('DEBUG', message, meta)); }
+  info(message: string, meta?: object): void { if (this.shouldLog('info')) console.info(this.format('INFO', message, meta)); }
+  warn(message: string, meta?: object): void { if (this.shouldLog('warn')) console.warn(this.format('WARN', message, meta)); }
+  error(message: string, meta?: object): void { if (this.shouldLog('error')) console.error(this.format('ERROR', message, meta)); }
+
+  private shouldLog(level: string): boolean { const levels = ['debug', 'info', 'warn', 'error']; return levels.indexOf(level) >= levels.indexOf(this.level); }
+  private format(level: string, message: string, meta?: object): string { return JSON.stringify({ timestamp: new Date().toISOString(), level, message, ...meta }); }
+}
+```
+
+## Error Handling Framework
+
+```typescript
+export abstract class BaseError extends Error {
+  abstract readonly code: string; abstract readonly category: 'validation' | 'api' | 'system' | 'user';
+  constructor(message: string, public readonly context?: Record<string, any>, public readonly cause?: Error) { super(message); this.name = this.constructor.name; }
+}
+
+export class ValidationError extends BaseError { readonly code = 'VALIDATION_ERROR'; readonly category = 'validation' as const; }
+
+export class ApiError extends BaseError {
+  readonly code = 'API_ERROR'; readonly category = 'api' as const;
+  constructor(message: string, public readonly status?: number, context?: Record<string, any>, cause?: Error) { super(message, { ...context, status }, cause); }
+}
+
+export class ContentstackApiError extends ApiError {
+  readonly code = 'CONTENTSTACK_API_ERROR';
+  static fromResponse(response: any, context?: Record<string, any>): ContentstackApiError {
+    return new ContentstackApiError(response.error_message || 'API request failed', response.error_code, { ...context, errorCode: response.error_code, details: response.errors });
+  }
+}
+```
+
+## Utility Classes
+
+### Rate Limiter
+```typescript
+export class RateLimiter {
+  private queue: Array<() => void> = []; private running = 0; private lastRequest = 0;
+  constructor(private maxConcurrent: number = 1, private minInterval: number = 100) {}
+
+  async execute<T>(operation: () => Promise<T>): Promise<T> {
+    return new Promise((resolve, reject) => {
+      this.queue.push(async () => {
+        try { await this.waitForInterval(); this.running++; const result = await operation(); resolve(result); }
+        catch (error) { reject(error); } finally { this.running--; this.processQueue(); }
+      });
+      this.processQueue();
+    });
+  }
+
+  private processQueue(): void { if (this.running < this.maxConcurrent && this.queue.length > 0) this.queue.shift()!(); }
+  private async waitForInterval(): Promise<void> {
+    const now = Date.now(); const elapsed = now - this.lastRequest;
+    if (elapsed < this.minInterval) await new Promise(resolve => setTimeout(resolve, this.minInterval - elapsed));
+    this.lastRequest = Date.now();
+  }
+}
+```
+
+### Retry Strategy
+```typescript
+export interface RetryOptions { maxAttempts: number; initialDelay: number; maxDelay: number; backoffFactor: number; retryCondition?: (error: any) => boolean; }
+
+export class RetryStrategy {
+  constructor(private options: RetryOptions) {}
+  async execute<T>(operation: () => Promise<T>): Promise<T> {
+    let lastError: any; let delay = this.options.initialDelay;
+    for (let attempt = 1; attempt <= this.options.maxAttempts; attempt++) {
+      try { return await operation(); }
+      catch (error) {
+        lastError = error; if (this.options.retryCondition && !this.options.retryCondition(error)) throw error;
+        if (attempt === this.options.maxAttempts) break; await new Promise(resolve => setTimeout(resolve, delay));
+        delay = Math.min(delay * this.options.backoffFactor, this.options.maxDelay);
+      }
+    }
+    throw lastError;
+  }
+
+  static forContentstack(): RetryStrategy {
+    return new RetryStrategy({ maxAttempts: 3, initialDelay: 1000, maxDelay: 10000, backoffFactor: 2, retryCondition: (error) => error.status === 429 || (error.status >= 500 && error.status < 600) });
+  }
+}
+```
+
+### Batch Processor
+```typescript
+export interface BatchOptions<T> { batchSize: number; concurrency: number; processor: (item: T) => Promise<any>; onProgress?: (completed: number, total: number) => void; }
+
+export class BatchProcessor {
+  static async process<T>(items: T[], options: BatchOptions<T>): Promise<any[]> {
+    const batches = this.chunk(items, options.batchSize); const allResults: any[] = []; let completed = 0;
+    const processBatch = async (batch: T[]): Promise<void> => {
+      const results = await Promise.allSettled(batch.map(options.processor)); allResults.push(...results); completed += batch.length; options.onProgress?.(completed, items.length);
+    };
+    const semaphore = new Semaphore(options.concurrency); await Promise.all(batches.map(batch => semaphore.acquire(() => processBatch(batch)))); return allResults;
+  }
+  private static chunk<T>(array: T[], size: number): T[][] { const chunks: T[][] = []; for (let i = 0; i < array.length; i += size) chunks.push(array.slice(i, i + size)); return chunks; }
+}
+
+class Semaphore {
+  private permits: number; private waiting: Array<() => void> = [];
+  constructor(permits: number) { this.permits = permits; }
+  async acquire<T>(task: () => Promise<T>): Promise<T> {
+    return new Promise((resolve, reject) => {
+      const tryAcquire = () => {
+        if (this.permits > 0) { this.permits--; task().then(resolve).catch(reject).finally(() => { this.permits++; if (this.waiting.length > 0) this.waiting.shift()!(); }); }
+        else this.waiting.push(tryAcquire);
+      };
+      tryAcquire();
+    });
+  }
+}
+```
+
+## File System & Validation Utilities
+
+```typescript
+export class FileUtil {
+  static async writeJson(filePath: string, data: any): Promise<void> {
+    try { const dir = path.dirname(filePath); await fs.mkdir(dir, { recursive: true }); await fs.writeFile(filePath, JSON.stringify(data, null, 2)); }
+    catch (error) { throw new Error(`Failed to write file ${filePath}: ${error.message}`); }
+  }
+  static async readJson<T>(filePath: string): Promise<T> {
+    try { const content = await fs.readFile(filePath, 'utf-8'); return JSON.parse(content); }
+    catch (error) { if (error.code === 'ENOENT') throw new Error(`File not found: ${filePath}`); throw new Error(`Failed to read file ${filePath}: ${error.message}`); }
+  }
+  static async exists(filePath: string): Promise<boolean> { try { await fs.access(filePath); return true; } catch { return false; } }
+}
+
+export class Validator {
+  static required(value: any, fieldName: string): void { if (value === null || value === undefined || value === '') throw new ValidationError(`${fieldName} is required`); }
+  static isArray(value: any, fieldName: string): void { if (!Array.isArray(value)) throw new ValidationError(`${fieldName} must be an array`); }
+  static isString(value: any, fieldName: string): void { if (typeof value !== 'string') throw new ValidationError(`${fieldName} must be a string`); }
+  static validateEnvironment(env: string): void { this.required(env, 'environment'); this.isString(env, 'environment'); }
+  static validateBatchSize(size: number): void { this.required(size, 'batchSize'); if (size < 1 || size > 100) throw new ValidationError('batchSize must be between 1 and 100'); }
+}
+```
+
+## Dependency Injection
+
+```typescript
+export class Container {
+  private services = new Map<string, any>(); private factories = new Map<string, () => any>();
+  register<T>(name: string, factory: () => T): void { this.factories.set(name, factory); }
+  get<T>(name: string): T {
+    if (this.services.has(name)) return this.services.get(name); const factory = this.factories.get(name); if (!factory) throw new Error(`Service not registered: ${name}`);
+    const instance = factory(); this.services.set(name, instance); return instance;
+  }
+  static setup(): Container {
+    const container = new Container(); container.register('config', () => ConfigBuilder.build()); container.register('logger', () => new ConsoleLogger());
+    container.register('rateLimiter', () => new RateLimiter(3, 100)); container.register('retryStrategy', () => RetryStrategy.forContentstack()); return container;
+  }
+}
+```
\ No newline at end of file
diff --git a/packages/contentstack-query-export/skills/testing/SKILL.md b/packages/contentstack-query-export/skills/testing/SKILL.md
new file mode 100644
index 000000000..35b660a82
--- /dev/null
+++ b/packages/contentstack-query-export/skills/testing/SKILL.md
@@ -0,0 +1,289 @@
+---
+name: testing
+description: Mocha/Chai/Sinon testing and TDD for @contentstack/cli-cm-export-query. Use when writing or debugging tests in test/unit/ or adjusting coverage.
+---
+
+# Testing Patterns
+
+Testing best practices and TDD workflow for **`@contentstack/cli-cm-export-query`**.
+
+**RED → GREEN → REFACTOR** for behavior changes; pure refactors / docs-only may skip new tests when behavior is unchanged.
+
+## Test Structure Standards
+
+### Basic Test Template
+```typescript
+describe('[ComponentName]', () => {
+  beforeEach(() => {
+    // Setup mocks and test data
+    sinon.stub(ExternalService.prototype, 'method').resolves(mockData);
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  it('should [expected behavior] when [condition]', () => {
+    // Arrange
+    const input = { /* test data */ };
+    
+    // Act
+    const result = component.method(input);
+    
+    // Assert
+    expect(result).to.equal(expectedOutput);
+  });
+});
+```
+
+### Command testing example
+```typescript
+describe('ExportQueryCommand', () => {
+  beforeEach(() => {
+    sinon.stub(ContentstackClient.prototype, 'stack').returns(mockStack);
+  });
+
+  it('should run export when query and auth are valid', async () => {
+    // Stub parse, setupQueryExportConfig, QueryExporter.prototype.execute, etc.
+  });
+});
+```
+
+## Key Testing Rules
+
+### Coverage
+- **~80%** (lines, branches, functions) is **aspirational**, not a hard gate
+- Test both success and failure paths
+- Include edge cases and error scenarios
+
+### Mocking Standards
+- **Use sinon** for API responses and external dependencies
+- **Never make real API calls** in tests
+- **Mock at module boundaries** (SDK, `fsUtil`), not irrelevant internals
+- Restore mocks in `afterEach()` to prevent test pollution
+
+### Test Patterns
+- Use descriptive test names: "should [behavior] when [condition]"
+- Keep test setup minimal and focused
+- Prefer synchronous patterns when possible
+- Group related tests in `describe` blocks
+
+## Common Mock Patterns
+
+### API Mocking
+```typescript
+// Mock Contentstack API
+sinon.stub(ContentstackClient.prototype, 'fetch').resolves(mockData);
+
+// Mock with specific responses
+sinon.stub(client, 'getEntry')
+  .withArgs('entry1').resolves(mockEntry1)
+  .withArgs('entry2').resolves(mockEntry2);
+```
+
+### Service Mocking
+```typescript
+// Mock rate limiter
+sinon.stub(RateLimiter.prototype, 'wait').resolves();
+
+// Mock file operations
+sinon.stub(fsUtil, 'writeFile').returns(true);
+sinon.stub(fsUtil, 'readFile').resolves(JSON.stringify(mockData));
+```
+
+### Error Simulation
+```typescript
+// Mock API errors
+const apiError = new Error('API Error');
+apiError.status = 500;
+sinon.stub(client, 'fetch').rejects(apiError);
+
+// Mock rate limiting
+const rateLimitError = new Error('Rate limited');
+rateLimitError.status = 429;
+sinon.stub(client, 'fetch').rejects(rateLimitError);
+```
+
+## Error Testing Patterns
+
+### Rate Limit Handling
+```typescript
+it('should handle rate limit errors', () => {
+  const error = new Error('Rate limited');
+  error.status = 429;
+  
+  sinon.stub(client, 'fetch').rejects(error);
+  
+  expect(service.performOperation()).to.eventually.be.fulfilled;
+});
+```
+
+### Validation Error Testing
+```typescript
+it('should throw validation error for invalid input', () => {
+  const invalidInput = { /* invalid data */ };
+  
+  expect(() => service.validate(invalidInput))
+    .to.throw('Validation failed');
+});
+```
+
+### Async Error Handling
+```typescript
+it('should handle async operation failures', async () => {
+  sinon.stub(service, 'performAsync').rejects(new Error('Operation failed'));
+  
+  try {
+    await service.execute();
+    expect.fail('Should have thrown error');
+  } catch (error) {
+    expect(error.message).to.include('Operation failed');
+  }
+});
+```
+
+## Test Organization
+
+### File Structure
+- Mirror modules under `test/unit/`: e.g. `test/unit/query-executor.test.ts`, `test/unit/query-parser-simple.test.ts`
+- Use consistent naming: `[module-name].test.ts`
+- Group integration tests: `test/integration/`
+
+### Test Data Management
+- Create mock data factories: `test/fixtures/mock-factory.ts`
+- Use realistic test data that matches API responses
+- Share common mocks across test files
+
+### Test Configuration
+```javascript
+// .mocharc.json
+{
+  "require": ["ts-node/register"],
+  "extensions": ["ts"],
+  "spec": "test/**/*.test.ts",
+  "timeout": 5000,
+  "forbid-only": true
+}
+```
+
+## Coverage and Quality
+
+### Coverage Enforcement
+```json
+// package.json nyc configuration
+"nyc": {
+  "check-coverage": true,
+  "lines": 80,
+  "functions": 80,
+  "branches": 80,
+  "statements": 80
+}
+```
+
+### Quality Checklist
+- [ ] All public methods tested
+- [ ] Error paths covered
+- [ ] Edge cases included
+- [ ] Mocks properly restored
+- [ ] No real API calls
+- [ ] Descriptive test names
+- [ ] Minimal test setup
+- [ ] Fast execution (< 5s per test)
+
+## Development workflow
+
+### TDD workflow (recommended)
+
+For **new behavior or bug fixes**, prefer:
+
+1. **RED** → Failing test (or extended test)
+2. **GREEN** → Minimal code to pass
+3. **REFACTOR** → Improve while tests stay green
+
+**Exceptions:** pure refactors, documentation-only edits, and trivial non-behavior changes may skip new tests.
+
+## Guidelines
+
+- Prefer **clear tests** over async-heavy setup when you can
+- **NO test.skip or .only** in commits
+- **~80% coverage** (lines, branches, functions) is **aspirational**, not a CI gate
+- **TypeScript** — explicit return types where practical; avoid `any`
+
+## File structure (this repo)
+
+- **Commands**: `src/commands/cm/stacks/`
+- **Core**: `src/core/` (`QueryExporter`, `ModuleExporter`, …)
+- **Utils**: `src/utils/`
+- **Tests**: `test/unit/` — `*.test.ts` per module (e.g. `query-executor.test.ts`)
+
+## Naming conventions
+
+- **Files**: `kebab-case.ts` / `kebab-case.test.ts`
+- **Classes**: `PascalCase`
+- **Functions/Variables**: `camelCase`
+- **Constants**: `SCREAMING_SNAKE_CASE`
+- **Test descriptions**: "should [behavior] when [condition]"
+
+## Code quality standards
+
+### TypeScript
+- Explicit return types for all functions
+- No `any` type usage
+- Strict null checks enabled
+- No unused variables or imports
+
+### Error handling
+- Use custom error classes where the codebase already does
+- Include error context and cause
+- Never swallow errors silently
+
+### Import organization
+1. Node.js built-ins
+2. External libraries
+3. Internal modules (relative imports last)
+
+## Testing
+
+### Coverage
+- Aim high; **~80%** is a guideline
+- Test success and failure paths for behavior you touch
+- Mock external dependencies (SDK, `fsUtil`, etc.)
+
+### Test structure
+```typescript
+describe('[ComponentName]', () => {
+  beforeEach(() => {
+    sinon.stub(ExternalService.prototype, 'method').resolves(mockData);
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  it('should [expected behavior] when [condition]', () => {
+    const input = { /* test data */ };
+    const result = component.method(input);
+    expect(result).to.equal(expectedOutput);
+  });
+});
+```
+
+### Mocking standards
+- Use sinon for API response mocking
+- Never make real API calls in tests
+- Mock at module boundaries (SDK, `fsUtil`, etc.), not irrelevant internals
+
+## Commit suggestions
+
+- Conventional commits are optional: `feat(scope): description`
+- Include tests when you change behavior
+- Run lint and tests before pushing
+- No debugging code (`console.log`, `debugger`) left in
+
+## Development process
+
+1. **Understand** → Read relevant patterns before coding
+2. **Plan** → Break down into testable units
+3. **Test first** → When adding behavior, prefer failing test then implementation
+4. **Validate** → `npm run lint`, `npm run test`, `npm run test:report` if you need LCOV
+5. **Review** → Self-review against the code review checklist
diff --git a/packages/contentstack-query-export/src/commands/cm/stacks/export-query.ts b/packages/contentstack-query-export/src/commands/cm/stacks/export-query.ts
new file mode 100644
index 000000000..e70e6c2de
--- /dev/null
+++ b/packages/contentstack-query-export/src/commands/cm/stacks/export-query.ts
@@ -0,0 +1,123 @@
+import { Command } from '@contentstack/cli-command';
+import {
+  flags,
+  FlagInput,
+  sanitizePath,
+  managementSDKClient,
+  ContentstackClient,
+  log,
+  handleAndLogError,
+  messageHandler,
+  loadChalk,
+} from '@contentstack/cli-utilities';
+import { QueryExporter } from '../../../core/query-executor';
+import { QueryExportConfig } from '../../../types';
+import { setupQueryExportConfig, setupBranches, createLogContext } from '../../../utils';
+
+export default class ExportQueryCommand extends Command {
+  static description = 'Export content from a stack using query-based filtering';
+  private exportDir: string;
+
+  static examples = [
+    'csdx cm:stacks:export-query --query \'{"modules":{"content-types":{"title":{"$in":["Blog","Author"]}}}}\'',
+    'csdx cm:stacks:export-query --query ./ct-query.json --skip-references',
+    'csdx cm:stacks:export-query --alias <alias> --query \'{"modules":{"entries":{"content_type_uid":"blog"}}}\'',
+    'csdx cm:stacks:export-query --query \'{"modules":{"assets":{"title":{"$regex":"image"}}}}\'',
+  ];
+
+  static usage = 'cm:stacks:export-query --query <value> [options]';
+
+  static flags: FlagInput = {
+    config: flags.string({
+      char: 'c',
+      description: 'Path to the configuration file',
+    }),
+    'stack-api-key': flags.string({
+      char: 'k',
+      description: 'Stack API key',
+    }),
+    'data-dir': flags.string({
+      char: 'd',
+      description: 'Path to store exported content',
+    }),
+    alias: flags.string({
+      char: 'a',
+      description: 'Management token alias',
+    }),
+    branch: flags.string({
+      description: 'Branch name to export from',
+      exclusive: ['branch-alias'],
+    }),
+    'branch-alias': flags.string({
+      description: 'Alias of Branch to export from',
+      exclusive: ['branch'],
+    }),
+    query: flags.string({
+      required: true,
+      description: 'Query as JSON string or file path',
+    }),
+    'skip-references': flags.boolean({
+      description: 'Skip referenced content types',
+    }),
+    'skip-dependencies': flags.boolean({
+      description: 'Skip dependent modules (global-fields, extensions, taxonomies)',
+    }),
+    'secured-assets': flags.boolean({
+      description: 'Export secured assets',
+    }),
+    yes: flags.boolean({
+      char: 'y',
+      description: 'Skip confirmation prompts',
+    }),
+  };
+
+  async run(): Promise<void> {
+    await loadChalk();
+    try {
+      const { flags } = await this.parse(ExportQueryCommand);
+      this.initializeMessageHandler();
+
+      // Setup export configuration
+      const exportQueryConfig = await setupQueryExportConfig(flags);
+      exportQueryConfig.host = this.cmaHost;
+      exportQueryConfig.region = this.region;
+
+      if (this.developerHubUrl) {
+        exportQueryConfig.developerHubBaseUrl = this.developerHubUrl;
+      }
+
+      this.exportDir = sanitizePath(exportQueryConfig.exportDir);
+      // Create base context without module name - module field is set dynamically during each module export
+      exportQueryConfig.context = createLogContext(exportQueryConfig);
+      log.debug('Export configuration setup completed', exportQueryConfig.context);
+
+      // Initialize management API client
+      const managementAPIClient: ContentstackClient = await managementSDKClient(exportQueryConfig);
+
+      // Setup and validate branch configuration
+      const stackAPIClient = managementAPIClient.stack({
+        api_key: exportQueryConfig.stackApiKey,
+        management_token: exportQueryConfig.managementToken,
+      });
+
+      // Setup branches (validate branch or set default to 'main')
+      await setupBranches(exportQueryConfig, stackAPIClient);
+      log.debug('Branch configuration setup completed', exportQueryConfig.context);
+
+      // Initialize and run query export
+      log.debug('Starting query exporter', exportQueryConfig.context);
+      const queryExporter = new QueryExporter(managementAPIClient, exportQueryConfig);
+      await queryExporter.execute();
+      log.debug('Query exporter completed successfully', exportQueryConfig.context);
+
+      log.success('Query-based export completed successfully!', exportQueryConfig.context);
+      log.info(`Export files saved to: ${this.exportDir}`, exportQueryConfig.context);
+    } catch (error) {
+      handleAndLogError(error);
+    }
+  }
+
+  initializeMessageHandler(): void {
+    messageHandler.init(this.context);
+  }
+}
diff --git a/packages/contentstack-query-export/src/config/export-config.json b/packages/contentstack-query-export/src/config/export-config.json
new file mode 100644
index 000000000..e8f2b1d2d
--- /dev/null
+++ b/packages/contentstack-query-export/src/config/export-config.json
@@ -0,0 +1 @@
+{ "skipDependencies": true, "skipStackSettings": false, "personalizationEnabled": true }
diff --git a/packages/contentstack-query-export/src/config/index.ts b/packages/contentstack-query-export/src/config/index.ts
new file mode 100644
index 000000000..c14af7e2c
--- /dev/null
+++ b/packages/contentstack-query-export/src/config/index.ts
@@ -0,0 +1,59 @@
+import { DefaultConfig } from '../types';
+
+const config: DefaultConfig = {
+  contentVersion: 2,
+  host: 'https://api.contentstack.io/v3',
+
+  // Query-based export module configuration
+  modules: {
+    // Always export - general modules
+    general: ['stack', 'locales', 'environments'],
+    // Query target modules
+    queryable: ['content-types'],
+    dependent: ['global-fields', 'extensions', 'marketplace-apps', 'taxonomies', 'personalize'],
+    // Content modules
+    content: ['entries', 'assets'],
+    // Export order based on dependencies
+    exportOrder: [
+      'stack',
+      'locales',
+      'environments',
+      'content-types',
+      'global-fields',
+      'extensions',
+      'taxonomies',
+      'entries',
+      'assets',
+    ],
+  },
+  // Query-specific settings
+  queryConfig: {
+    maxRecursionDepth: 10,
+    batchSize: 100,
+    metadataFileName: '_query-meta.json',
+    validation: {
+      maxQueryDepth: 5,
+      maxArraySize: 1000,
+      allowedDateFormats: ['ISO8601', 'YYYY-MM-DD', 'MM/DD/YYYY'],
+    },
+  },
+  // API endpoints
+  apis: {
+    stacks: '/stacks/',
+    locales: '/locales/',
+    environments: '/environments/',
+    content_types: '/content_types/',
+    global_fields: '/global_fields/',
+    extensions: '/extensions/',
+    taxonomies: '/taxonomies/',
+    entries: '/entries/',
+    assets: '/assets/',
+  },
+  // Performance settings
+  fetchConcurrency: 5,
+  writeConcurrency: 5,
+  maxCTReferenceDepth: 20,
+  // Optional settings
+};
+
+export default config;
diff --git a/packages/contentstack-query-export/src/core/module-exporter.ts b/packages/contentstack-query-export/src/core/module-exporter.ts
new file mode 100644
index 000000000..ac21ae9f0
--- /dev/null
+++ b/packages/contentstack-query-export/src/core/module-exporter.ts
@@ -0,0 +1,95 @@
+import { log, handleAndLogError } from '@contentstack/cli-utilities';
+import ExportCommand from '@contentstack/cli-cm-export';
+import { QueryExportConfig, Modules, ExportOptions } from '../types';
+
+export class ModuleExporter {
+  private exportQueryConfig: QueryExportConfig;
+  private exportedModules: string[] = [];
+
+  constructor(exportQueryConfig: QueryExportConfig) {
+    this.exportQueryConfig = exportQueryConfig;
+  }
+
+  async exportModule(moduleName: Modules, options: ExportOptions = {}): Promise<void> {
+    try {
+      const moduleLogContext = { ...this.exportQueryConfig.context, module: moduleName };
+      log.info(`Exporting module: ${moduleName}`, moduleLogContext);
+      log.debug(`Building export command for module: ${moduleName}`, moduleLogContext);
+
+      // Build command arguments
+      const cmd = this.buildExportCommand(moduleName, options);
+
+      // Configurable delay
+      const delay = this.exportQueryConfig.exportDelayMs || 2000;
+      await new Promise((resolve) => setTimeout(resolve, delay));
+
+      // Create export command instance
+      await ExportCommand.run(cmd);
+      log.debug(`Export command completed for module: ${moduleName}`, moduleLogContext);
+
+      // Read the exported data
+      // const data = await this.readExportedData(moduleName, options);
+
+      if (!this.exportedModules.includes(moduleName)) {
+        this.exportedModules.push(moduleName);
+      }
+
+      // success message
+      log.success(`Successfully exported ${moduleName}`, moduleLogContext);
+    } catch (error) {
+      const moduleLogContext = { ...this.exportQueryConfig.context, module: moduleName };
+      handleAndLogError(error, moduleLogContext, `Failed to export ${moduleName}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Build export command arguments based on module and options
+   */
+  private buildExportCommand(moduleName: Modules, options: ExportOptions): string[] {
+    const cmd: string[] = [];
+
+    // Stack API key (required)
+    cmd.push('-k', this.exportQueryConfig.stackApiKey);
+
+    // Directory
+    const directory = options.directory || this.exportQueryConfig.exportDir;
+    cmd.push('-d', directory);
+
+    // Module
+    cmd.push('--module', moduleName);
+
+    // Alias or management token (mutually exclusive for the export CLI)
+    if (options.alias) {
+      cmd.push('-a', options.alias);
+    } else if (this.exportQueryConfig.managementToken) {
+      cmd.push('-a', this.exportQueryConfig.managementToken);
+    }
+
+    // Branch
+    if (options.branch || this.exportQueryConfig.branchName) {
+      cmd.push('--branch', options.branch || this.exportQueryConfig.branchName);
+    }
+
+    // Query (if provided)
+    if (options.query) {
+      cmd.push('--query', JSON.stringify(options.query));
+    }
+
+    // Secured assets
+    if (options.securedAssets || this.exportQueryConfig.securedAssets) {
+      cmd.push('--secured-assets');
+    }
+
+    // External config file
+    const externalConfigPath = options.configPath || this.exportQueryConfig.externalConfigPath;
+    if (externalConfigPath) {
+      cmd.push('--config', externalConfigPath);
+    }
+
+    // Auto confirm
+    cmd.push('-y');
+
+    return cmd;
+  }
+}
diff --git a/packages/contentstack-query-export/src/core/query-executor.ts b/packages/contentstack-query-export/src/core/query-executor.ts
new file mode 100644
index 000000000..dd48183df
--- /dev/null
+++ b/packages/contentstack-query-export/src/core/query-executor.ts
@@ -0,0 +1,394 @@
+import {
+  ContentstackClient,
+  sanitizePath,
+  log,
+  handleAndLogError,
+  readContentTypeSchemas,
+} from '@contentstack/cli-utilities';
+import * as fs from 'fs';
+import * as path from 'path';
+import { QueryExportConfig, Modules } from '../types';
+import { QueryParser } from '../utils/query-parser';
+import { ModuleExporter } from './module-exporter';
+import { ReferencedContentTypesHandler } from '../utils';
+import { fsUtil } from '../utils';
+import { ContentTypeDependenciesHandler } from '../utils';
+import { AssetReferenceHandler } from '../utils';
+
+export class QueryExporter {
+  private stackAPIClient: ReturnType<ContentstackClient['stack']>;
+  private exportQueryConfig: QueryExportConfig;
+  private queryParser: QueryParser;
+  private moduleExporter: ModuleExporter;
+
+  constructor(managementAPIClient: ContentstackClient, exportQueryConfig: QueryExportConfig) {
+    this.exportQueryConfig = exportQueryConfig;
+
+    this.stackAPIClient = managementAPIClient.stack({
+      api_key: exportQueryConfig.stackApiKey,
+      management_token: exportQueryConfig.managementToken,
+    });
+    // Initialize components
+    this.queryParser = new QueryParser(this.exportQueryConfig);
+    this.moduleExporter = new ModuleExporter(exportQueryConfig);
+  }
+
+  async execute(): Promise<void> {
+    log.info('Starting query-based export...', this.exportQueryConfig.context);
+
+    // Step 1: Parse and validate query
+    log.debug('Parsing and validating query', this.exportQueryConfig.context);
+    const parsedQuery = await this.queryParser.parse(this.exportQueryConfig.query);
+    log.success('Query parsed and validated successfully', this.exportQueryConfig.context);
+
+    // Step 2: Always export general modules
+    await this.exportGeneralModules();
+
+    // Step 4: Export queried modules
+    await this.exportQueriedModule(parsedQuery);
+
+    // Step 5+6: resolve the full transitive closure of referenced content types,
+    // global fields, extensions, taxonomies, and marketplace apps.
+    log.debug('Starting schema closure expansion', this.exportQueryConfig.context);
+    await this.expandSchemaClosure();
+    // Step 7: export content modules entries, assets
+    log.debug('Starting content modules export', this.exportQueryConfig.context);
+    await this.exportContentModules();
+    // Step 9: export all other modules
+
+    log.success('Query-based export completed successfully!', this.exportQueryConfig.context);
+  }
+
+  // export general modules
+  private async exportGeneralModules(): Promise<void> {
+    log.info('Exporting general modules...', this.exportQueryConfig.context);
+
+    for (const module of this.exportQueryConfig.modules.general) {
+      await this.moduleExporter.exportModule(module);
+    }
+  }
+
+  private async exportQueriedModule(parsedQuery: any): Promise<void> {
+    log.debug('Starting queried module export', this.exportQueryConfig.context);
+    for (const [moduleName] of Object.entries(parsedQuery.modules)) {
+      const module = moduleName as Modules;
+
+      if (!this.exportQueryConfig.modules.queryable.includes(module)) {
+        log.error(`Module "${module}" is not queryable`, this.exportQueryConfig.context);
+        continue;
+      }
+
+      log.info(`Exporting ${moduleName} with query...`, this.exportQueryConfig.context);
+      // Export the queried module
+      await this.moduleExporter.exportModule(module, { query: parsedQuery });
+    }
+    log.debug('Queried module export completed', this.exportQueryConfig.context);
+  }
+
+  /**
+   * Iteratively expand the set of exported content types, global fields, extensions,
+   * taxonomies, and marketplace apps until no new items are discovered (fixpoint).
+   *
+   * Each iteration scans the combined set of CT and GF documents that currently exist on
+   * disk.  Any newly discovered referenced content types or global fields are exported and
+   * the loop restarts so that their schemas can be scanned in turn.  Leaf dependencies
+   * (extensions, taxonomies, marketplace apps) are collected and exported in the same pass
+   * without triggering an extra iteration, since they do not themselves produce new schemas.
+   *
+   * Personalize is exported exactly once, after the closure stabilises.
+   */
+  private async expandSchemaClosure(): Promise<void> {
+    log.info('Starting export of referenced content types and dependent modules...', this.exportQueryConfig.context);
+
+    try {
+      const ctPath = path.join(
+        sanitizePath(this.exportQueryConfig.exportDir),
+        sanitizePath(this.exportQueryConfig.branchName || ''),
+        'content_types',
+      );
+      const gfPath = path.join(
+        sanitizePath(this.exportQueryConfig.exportDir),
+        sanitizePath(this.exportQueryConfig.branchName || ''),
+        'global_fields',
+      );
+
+      const referencedHandler = new ReferencedContentTypesHandler(this.exportQueryConfig);
+      const dependenciesHandler = new ContentTypeDependenciesHandler(this.stackAPIClient, this.exportQueryConfig);
+
+      const exportedCTUIDs = new Set<string>();
+      const exportedGFUIDs = new Set<string>();
+      const exportedExtUIDs = new Set<string>();
+      const exportedTaxUIDs = new Set<string>();
+      const exportedMarketplaceUIDs = new Set<string>();
+
+      let iterationCount = 0;
+
+      while (iterationCount < this.exportQueryConfig.maxCTReferenceDepth) {
+        iterationCount++;
+        log.debug(`Schema closure iteration ${iterationCount}`, this.exportQueryConfig.context);
+
+        const allCTs = readContentTypeSchemas(ctPath);
+        const allGFs = readContentTypeSchemas(gfPath);
+
+        // Record everything currently on disk so we never re-export it.
+        allCTs.forEach((ct: any) => exportedCTUIDs.add(ct.uid));
+        allGFs.forEach((gf: any) => exportedGFUIDs.add(gf.uid));
+
+        const allSchemas = [...allCTs, ...allGFs];
+
+        if (allSchemas.length === 0) {
+          log.info('No schemas found on disk, stopping closure', this.exportQueryConfig.context);
+          break;
+        }
+
+        let foundNewCTs = false;
+        let foundNewGFs = false;
+
+        // Step A: find and export referenced content types from the combined schema set.
+        if (!this.exportQueryConfig.skipReferences) {
+          const referencedUIDs = await referencedHandler.extractReferencedContentTypes(allSchemas);
+          const newCTUIDs = referencedUIDs.filter((uid: string) => !exportedCTUIDs.has(uid));
+
+          if (newCTUIDs.length > 0) {
+            log.info(
+              `Found ${newCTUIDs.length} new referenced content type(s) to fetch`,
+              this.exportQueryConfig.context,
+            );
+            await this.moduleExporter.exportModule('content-types', {
+              query: { modules: { 'content-types': { uid: { $in: newCTUIDs } } } },
+            });
+            // Track immediately so the dedup filter works even if the disk reader
+            // hasn't picked up the newly written files yet.
+            newCTUIDs.forEach((uid: string) => exportedCTUIDs.add(uid));
+            foundNewCTs = true;
+          }
+        }
+
+        // Step B: find and export dependent modules from the combined schema set.
+        if (!this.exportQueryConfig.skipDependencies) {
+          const deps = await dependenciesHandler.extractDependencies(allSchemas);
+
+          const newGFUIDs = [...deps.globalFields].filter((uid: string) => !exportedGFUIDs.has(uid));
+          if (newGFUIDs.length > 0) {
+            log.info(`Found ${newGFUIDs.length} new global field(s)`, this.exportQueryConfig.context);
+            await this.moduleExporter.exportModule('global-fields', {
+              query: { modules: { 'global-fields': { uid: { $in: newGFUIDs } } } },
+            });
+            // Track immediately for the same reason as CTs above.
+            newGFUIDs.forEach((uid: string) => exportedGFUIDs.add(uid));
+            foundNewGFs = true;
+          }
+
+          // Extensions, taxonomies, and marketplace apps are leaf nodes: they do not
+          // produce new schemas, so exporting them never requires an extra iteration.
+          const newExtUIDs = [...deps.extensions].filter((uid: string) => !exportedExtUIDs.has(uid));
+          if (newExtUIDs.length > 0) {
+            log.info(`Found ${newExtUIDs.length} new extension(s)`, this.exportQueryConfig.context);
+            await this.moduleExporter.exportModule('extensions', {
+              query: { modules: { extensions: { uid: { $in: newExtUIDs } } } },
+            });
+            newExtUIDs.forEach((uid: string) => exportedExtUIDs.add(uid));
+          }
+
+          const newMarketplaceUIDs = [...deps.marketplaceApps].filter(
+            (uid: string) => !exportedMarketplaceUIDs.has(uid),
+          );
+          if (newMarketplaceUIDs.length > 0) {
+            log.info(`Found ${newMarketplaceUIDs.length} new marketplace app(s)`, this.exportQueryConfig.context);
+            await this.moduleExporter.exportModule('marketplace-apps', {
+              query: { modules: { 'marketplace-apps': { installation_uid: { $in: newMarketplaceUIDs } } } },
+            });
+            newMarketplaceUIDs.forEach((uid: string) => exportedMarketplaceUIDs.add(uid));
+          }
+
+          const newTaxUIDs = [...deps.taxonomies].filter((uid: string) => !exportedTaxUIDs.has(uid));
+          if (newTaxUIDs.length > 0) {
+            log.info(`Found ${newTaxUIDs.length} new taxonom(ies)`, this.exportQueryConfig.context);
+            await this.moduleExporter.exportModule('taxonomies', {
+              query: { modules: { taxonomies: { uid: { $in: newTaxUIDs } } } },
+            });
+            newTaxUIDs.forEach((uid: string) => exportedTaxUIDs.add(uid));
+          }
+        }
+
+        if (!foundNewCTs && !foundNewGFs) {
+          log.info('Schema closure complete, no new content types or global fields found', this.exportQueryConfig.context);
+          break;
+        }
+      }
+
+      // Personalize is a single global module exported once after the closure stabilises.
+      await this.moduleExporter.exportModule('personalize');
+
+      log.success('Referenced content types and dependent modules exported successfully', this.exportQueryConfig.context);
+    } catch (error) {
+      handleAndLogError(error, this.exportQueryConfig.context, 'Error during schema closure expansion');
+      throw error;
+    }
+  }
+
+  private async exportContentModules(): Promise<void> {
+    log.info('Starting export of content modules...', this.exportQueryConfig.context);
+
+    try {
+      // Step 1: Export entries for all exported content types
+      await this.exportEntries();
+
+      // Step 2: Export referenced assets from entries
+      // add a delay of 5 seconds
+      const delay = (this.exportQueryConfig as any).exportDelayMs || 5000;
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      await this.exportReferencedAssets();
+
+      log.success('Content modules export completed successfully', this.exportQueryConfig.context);
+    } catch (error) {
+      handleAndLogError(error, this.exportQueryConfig.context, 'Error exporting content modules');
+      throw error;
+    }
+  }
+
+  private async exportEntries(): Promise<void> {
+    log.info('Exporting entries...', this.exportQueryConfig.context);
+
+    try {
+      // Export entries - module exporter will automatically read exported content types
+      // and export entries for all of them
+      await this.moduleExporter.exportModule('entries');
+
+      log.success('Entries export completed successfully', this.exportQueryConfig.context);
+    } catch (error) {
+      handleAndLogError(error, this.exportQueryConfig.context, 'Error exporting entries');
+      throw error;
+    }
+  }
+
+  private async exportReferencedAssets(): Promise<void> {
+    log.info('Starting export of referenced assets...', this.exportQueryConfig.context);
+
+    try {
+      const assetsDir = path.join(
+        sanitizePath(this.exportQueryConfig.exportDir),
+        sanitizePath(this.exportQueryConfig.branchName || ''),
+        'assets',
+      );
+
+      const metadataFilePath = path.join(assetsDir, 'metadata.json');
+      const assetFilePath = path.join(assetsDir, 'assets.json');
+
+      // Define temp file paths
+      const tempMetadataFilePath = path.join(assetsDir, 'metadata_temp.json');
+      const tempAssetFilePath = path.join(assetsDir, 'assets_temp.json');
+
+      const assetHandler = new AssetReferenceHandler(this.exportQueryConfig);
+
+      // Extract referenced asset UIDs from all entries
+      log.debug('Extracting referenced assets from entries', this.exportQueryConfig.context);
+      const assetUIDs = assetHandler.extractReferencedAssets();
+
+      if (assetUIDs.length > 0) {
+        log.info(`Found ${assetUIDs.length} referenced assets to export`, this.exportQueryConfig.context);
+
+        fs.mkdirSync(assetsDir, { recursive: true });
+
+        // Define batch size - can be configurable through exportQueryConfig
+        const batchSize = this.exportQueryConfig.assetBatchSize || 100;
+
+        // if asset size is bigger than batch size, then we need to export in batches
+        // Calculate number of batches
+        const totalBatches = Math.ceil(assetUIDs.length / batchSize);
+        log.info(`Processing assets in ${totalBatches} batches of ${batchSize}`, this.exportQueryConfig.context);
+
+        // Process assets in batches
+        for (let i = 0; i < totalBatches; i++) {
+          const start = i * batchSize;
+          const end = Math.min(start + batchSize, assetUIDs.length);
+          const batchAssetUIDs = assetUIDs.slice(start, end);
+
+          log.info(
+            `Exporting batch ${i + 1}/${totalBatches} (${batchAssetUIDs.length} assets)...`,
+            this.exportQueryConfig.context,
+          );
+
+          const query = {
+            modules: {
+              assets: {
+                uid: { $in: batchAssetUIDs },
+              },
+            },
+          };
+
+          await this.moduleExporter.exportModule('assets', { query });
+
+          // Read the current batch's metadata.json and assets.json files
+          const currentMetadata: any = fsUtil.readFile(sanitizePath(metadataFilePath));
+          const currentAssets: any = fsUtil.readFile(sanitizePath(assetFilePath));
+
+          // Check if this is the first batch
+          if (i === 0) {
+            // For first batch, initialize temp files with current content
+            fsUtil.writeFile(sanitizePath(tempMetadataFilePath), currentMetadata);
+            fsUtil.writeFile(sanitizePath(tempAssetFilePath), currentAssets);
+            log.info(`Initialized temporary files with first batch data`, this.exportQueryConfig.context);
+          } else {
+            // For subsequent batches, append to temp files with incremented keys
+
+            // Handle metadata (which contains arrays of asset info)
+            const tempMetadata: any = fsUtil.readFile(sanitizePath(tempMetadataFilePath)) || {};
+
+            // Merge metadata by combining arrays
+            if (currentMetadata) {
+              Object.keys(currentMetadata).forEach((key: string) => {
+                if (!tempMetadata[key]) {
+                  tempMetadata[key] = currentMetadata[key];
+                }
+              });
+            }
+
+            // Write updated metadata back to temp file
+            fsUtil.writeFile(sanitizePath(tempMetadataFilePath), tempMetadata);
+
+            // Handle assets (which is an object with numeric keys)
+            const tempAssets: any = fsUtil.readFile(sanitizePath(tempAssetFilePath)) || {};
+            let nextIndex = Object.keys(tempAssets).length + 1;
+
+            // Add current assets with incremented keys
+            Object.values(currentAssets).forEach((value: any) => {
+              tempAssets[nextIndex.toString()] = value;
+              nextIndex++;
+            });
+
+            fsUtil.writeFile(sanitizePath(tempAssetFilePath), tempAssets);
+
+            log.info(`Updated temporary files with batch ${i + 1} data`, this.exportQueryConfig.context);
+          }
+
+          // Optional: Add delay between batches to avoid rate limiting
+          if (i < totalBatches - 1 && this.exportQueryConfig.batchDelayMs) {
+            await new Promise((resolve) => setTimeout(resolve, this.exportQueryConfig.batchDelayMs));
+          }
+        }
+
+        // After all batches are processed, copy temp files back to original files
+        const finalMetadata = fsUtil.readFile(sanitizePath(tempMetadataFilePath));
+        const finalAssets = fsUtil.readFile(sanitizePath(tempAssetFilePath));
+
+        fsUtil.writeFile(sanitizePath(metadataFilePath), finalMetadata);
+        fsUtil.writeFile(sanitizePath(assetFilePath), finalAssets);
+
+        log.info(`Final data written back to original files`, this.exportQueryConfig.context);
+
+        // Clean up temp files
+        fsUtil.removeFile(sanitizePath(tempMetadataFilePath));
+        fsUtil.removeFile(sanitizePath(tempAssetFilePath));
+
+        log.info(`Temporary files cleaned up`, this.exportQueryConfig.context);
+        log.success('Referenced assets exported successfully', this.exportQueryConfig.context);
+      } else {
+        log.info('No referenced assets found in entries', this.exportQueryConfig.context);
+      }
+    } catch (error) {
+      handleAndLogError(error, this.exportQueryConfig.context, 'Error exporting referenced assets');
+      throw error;
+    }
+  }
+}
diff --git a/packages/contentstack-query-export/src/types/index.ts b/packages/contentstack-query-export/src/types/index.ts
new file mode 100644
index 000000000..1a036ea24
--- /dev/null
+++ b/packages/contentstack-query-export/src/types/index.ts
@@ -0,0 +1,226 @@
+import { ContentstackClient } from '@contentstack/cli-utilities';
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export interface AuthOptions {
+  contentstackClient: any;
+}
+
+export interface ContentStackManagementClient {
+  contentstackClient: object;
+}
+
+export interface PrintOptions {
+  color?: string;
+}
+
+export interface InquirePayload {
+  type: string;
+  name: string;
+  message: string;
+  choices?: Array<any>;
+  transformer?: Function;
+}
+
+export interface User {
+  email: string;
+  authtoken: string;
+}
+
+export interface Region {
+  name: string;
+  cma: string;
+  cda: string;
+  uiHost: string;
+}
+
+export type Modules =
+  | 'stack'
+  | 'locales'
+  | 'environments'
+  | 'content-types'
+  | 'global-fields'
+  | 'extensions'
+  | 'taxonomies'
+  | 'entries'
+  | 'assets'
+  | 'webhooks'
+  | 'workflows'
+  | 'custom-roles'
+  | 'labels'
+  | 'marketplace-apps'
+  | 'personalize';
+
+export interface ModuleQueryConfig {
+  supportedFields: string[];
+  supportedOperators: string[];
+  defaultLimit: number;
+  includeGlobalFieldSchema?: boolean;
+  includePublishDetails?: boolean;
+  includeDimension?: boolean;
+}
+
+export interface DependencyAnalysisConfig {
+  enabled: boolean;
+  fields?: string[];
+  extractors?: string[];
+}
+
+export interface ModuleDefinition {
+  dirName: string;
+  fileName: string;
+  apiEndpoint: string;
+  queryable: boolean;
+  dependencies: Modules[];
+  queryConfig?: ModuleQueryConfig;
+  dependencyAnalysis?: DependencyAnalysisConfig;
+  limit?: number;
+  batchLimit?: number;
+}
+
+export interface DependencyExtractor {
+  fieldType: string;
+  extract: (data: any) => string[];
+  targetModule: Modules;
+}
+
+export interface ExportOptions {
+  query?: any;
+  alias?: string;
+  directory?: string;
+  branch?: string;
+  skipReferences?: boolean;
+  skipDependencies?: boolean;
+  securedAssets?: boolean;
+  includeGlobalFieldSchema?: boolean;
+  includePublishDetails?: boolean;
+  includeDimension?: boolean;
+  contentTypes?: string[];
+  uids?: string[];
+  configPath?: string;
+  fetchConcurrency?: number;
+  writeConcurrency?: number;
+  batchSize?: number;
+  [key: string]: any;
+}
+
+export interface DefaultConfig {
+  // Basic settings
+  contentVersion: number;
+  host: string;
+
+  // Export settings
+  exportDir?: string;
+  stackApiKey?: string;
+  managementToken?: string;
+  region?: Region;
+  branchName?: string;
+  securedAssets?: boolean;
+
+  // Query settings
+  query?: string;
+  queryInput?: string;
+  skipReferences?: boolean;
+  skipDependencies?: boolean;
+  isQueryBasedExport?: boolean;
+
+  // Module configuration
+  modules: {
+    general: Modules[];
+    queryable: Modules[];
+    dependent: Modules[];
+    content: Modules[];
+    // Export order
+    exportOrder: Modules[];
+    // Module definitions
+    definitions?: Record<Modules, ModuleDefinition>;
+  };
+
+  // Query-specific settings
+  queryConfig: {
+    maxRecursionDepth?: number;
+    batchSize?: number;
+    metadataFileName?: string;
+    validation: {
+      maxQueryDepth?: number;
+      maxArraySize?: number;
+      allowedDateFormats?: string[];
+    };
+  };
+
+  // Dependency extraction rules
+  dependencyExtractors?: Record<string, DependencyExtractor>;
+
+  // Performance settings
+  fetchConcurrency: number;
+  writeConcurrency: number;
+
+  // Optional settings
+  developerHubBaseUrl?: string;
+  branches?: Array<{ uid: string; source: string }>;
+  branchEnabled?: boolean;
+  branchDir?: string;
+  apis: {
+    stacks: string;
+    locales: string;
+    environments: string;
+    content_types: string;
+    global_fields: string;
+    extensions: string;
+    taxonomies: string;
+    entries: string;
+    assets: string;
+  };
+  externalConfigPath?: string;
+  maxCTReferenceDepth: number;
+}
+
+/**
+ * Log context interface for centralized logging
+ */
+export interface LogContext {
+  command: string;
+  module: string;
+  email: string;
+  sessionId: string;
+  apiKey: string;
+  orgId: string;
+  authenticationMethod: string;
+  [key: string]: unknown;
+}
+
+export interface QueryExportConfig extends DefaultConfig {
+  query: string;
+  skipReferences: boolean;
+  skipDependencies: boolean;
+  stackApiKey: string;
+  managementToken?: string;
+  branchName: string;
+  branchAlias?: string;
+  securedAssets: boolean;
+  logsPath: string;
+  dataPath: string;
+  exportDelayMs?: number;
+  batchDelayMs?: number;
+  assetBatchSize?: number;
+  assetBatchDelayMs?: number;
+  context?: LogContext; // Log context for centralized logging
+}
+
+export interface QueryMetadata {
+  query: any;
+  flags: {
+    skipReferences: boolean;
+    skipDependencies: boolean;
+  };
+  timestamp: string;
+  cliVersion: string;
+  exportedModules: string[];
+  contentTypes: Array<{
+    uid: string;
+    title: string;
+  }>;
+  summary: {
+    totalContentTypes: number;
+    totalModules: number;
+  };
+}
diff --git a/packages/contentstack-query-export/src/utils/branch-helper.ts b/packages/contentstack-query-export/src/utils/branch-helper.ts
new file mode 100644
index 000000000..43b007840
--- /dev/null
+++ b/packages/contentstack-query-export/src/utils/branch-helper.ts
@@ -0,0 +1,70 @@
+
+import { getBranchFromAlias, log, handleAndLogError } from '@contentstack/cli-utilities';
+import { QueryExportConfig } from '../types';
+
+/**
+ * Validates and sets up branch configuration for the stack
+ *
+ * @param config The export configuration
+ * @param stackAPIClient The stack API client
+ * @returns Promise that resolves when branch setup is complete
+ */
+export const setupBranches = async (config: QueryExportConfig, stackAPIClient: any): Promise<void> => {
+  if (typeof config !== 'object') {
+    throw new Error('The branch configuration is invalid.');
+  }
+
+  const context = config.context;
+
+  try {
+    if (config.branchAlias) {
+      config.branchName = await getBranchFromAlias(stackAPIClient, config.branchAlias);
+      return;
+    }
+    if (config.branchName) {
+      // Check if the specified branch exists
+      log.info(`Validating branch: ${config.branchName}`, context);
+
+      const result = await stackAPIClient
+        .branch(config.branchName)
+        .fetch()
+        .catch((err: unknown): any => {
+          handleAndLogError(err, context, 'Error fetching branch');
+          return null;
+        });
+
+      if (result && typeof result === 'object') {
+        log.success(`Branch '${config.branchName}' found`, context);
+      } else {
+        throw new Error(`No branch found named ${config.branchName}.`);
+      }
+    } else {
+      // If no branch name provided, check if the stack has branches
+      log.info('No branch specified, checking if stack has branches', context);
+
+      const result = await stackAPIClient
+        .branch()
+        .query()
+        .find()
+        .catch((): any => {
+          log.info('Stack does not have branches', context);
+          return null;
+        });
+
+      if (result && result.items && Array.isArray(result.items) && result.items.length > 0) {
+        // Set default branch to 'main' if it exists
+        config.branchName = 'main';
+      } else {
+        // Stack doesn't have branches
+        log.info('Stack does not have branches', context);
+        return;
+      }
+    }
+    config.branchEnabled = true;
+  } catch (error) {
+    handleAndLogError(error, context, 'Error setting up branches');
+    throw error;
+  }
+};
+
+export default setupBranches;
diff --git a/packages/contentstack-query-export/src/utils/common-helper.ts b/packages/contentstack-query-export/src/utils/common-helper.ts
new file mode 100644
index 000000000..724e2f5b1
--- /dev/null
+++ b/packages/contentstack-query-export/src/utils/common-helper.ts
@@ -0,0 +1,9 @@
+import { cliux } from '@contentstack/cli-utilities';
+
+export const askAPIKey = async (): Promise<string> => {
+  return await cliux.inquire<string>({
+    type: 'input',
+    message: 'Enter the stack api key',
+    name: 'apiKey',
+  });
+};
diff --git a/packages/contentstack-query-export/src/utils/config-handler.ts b/packages/contentstack-query-export/src/utils/config-handler.ts
new file mode 100644
index 000000000..94eccfc65
--- /dev/null
+++ b/packages/contentstack-query-export/src/utils/config-handler.ts
@@ -0,0 +1,56 @@
+import * as path from 'path';
+import { QueryExportConfig } from '../types';
+import { sanitizePath, pathValidator, configHandler, isAuthenticated } from '@contentstack/cli-utilities';
+import config from '../config';
+import { askAPIKey } from './common-helper';
+
+export async function setupQueryExportConfig(flags: any): Promise<QueryExportConfig> {
+  const exportDir = sanitizePath(flags['data-dir'] || pathValidator('export'));
+
+  const exportQueryConfig: QueryExportConfig = {
+    ...config,
+    exportDir,
+    stackApiKey: flags['stack-api-key'] || '',
+    managementToken: flags.alias ? configHandler.get(`tokens.${flags.alias}`)?.token : undefined,
+    query: flags.query,
+    skipReferences: flags['skip-references'] || false,
+    skipDependencies: flags['skip-dependencies'] || false,
+    branchName: flags.branch,
+    securedAssets: flags['secured-assets'] || false,
+    isQueryBasedExport: true,
+    logsPath: exportDir,
+    dataPath: exportDir,
+    // Todo: accept the path of the config file from the user
+    externalConfigPath: path.join(__dirname, '../config/export-config.json'),
+  };
+
+  if (flags['branch-alias']) {
+    exportQueryConfig.branchAlias = flags['branch-alias'];
+  }
+  // override the external config path if the user provides a config file
+  if (flags.config) {
+    exportQueryConfig.externalConfigPath = sanitizePath(flags['config']);
+  }
+
+  // Handle authentication
+  if (flags.alias) {
+    const { token, apiKey } = configHandler.get(`tokens.${flags.alias}`) || {};
+    exportQueryConfig.managementToken = token;
+    exportQueryConfig.stackApiKey = apiKey;
+    if (!exportQueryConfig.managementToken) {
+      throw new Error(`No management token found for alias ${flags.alias}.`);
+    }
+  }
+
+  if (!exportQueryConfig.managementToken) {
+    if (!isAuthenticated()) {
+      throw new Error('Log in or provide an alias for the management token.');
+    } else {
+      exportQueryConfig.stackApiKey = flags['stack-api-key'] || (await askAPIKey());
+      if (typeof exportQueryConfig.stackApiKey !== 'string') {
+        throw new Error('The API key is invalid.');
+      }
+    }
+  }
+  return exportQueryConfig;
+}
diff --git a/packages/contentstack-query-export/src/utils/content-type-helper.ts b/packages/contentstack-query-export/src/utils/content-type-helper.ts
new file mode 100644
index 000000000..376be7f54
--- /dev/null
+++ b/packages/contentstack-query-export/src/utils/content-type-helper.ts
@@ -0,0 +1,102 @@
+import * as path from 'path';
+import { log } from '@contentstack/cli-utilities';
+import { QueryExportConfig } from '../types';
+
+export class ReferencedContentTypesHandler {
+  private exportQueryConfig: QueryExportConfig;
+
+  constructor(exportQueryConfig: QueryExportConfig) {
+    this.exportQueryConfig = exportQueryConfig;
+  }
+
+  /**
+   * Extract referenced content types from a batch of content types
+   * This method only processes the given batch, doesn't orchestrate the entire process
+   */
+  async extractReferencedContentTypes(contentTypeBatch: any[]): Promise<string[]> {
+    const allReferencedTypes: Set<string> = new Set();
+
+    log.info(`Extracting references from ${contentTypeBatch.length} content types`, this.exportQueryConfig.context);
+
+    for (const contentType of contentTypeBatch) {
+      if (contentType.schema) {
+        const referencedTypes = this.getReferencedContentTypes(contentType.schema);
+        referencedTypes.forEach((type) => allReferencedTypes.add(type));
+      }
+    }
+
+    const result = Array.from(allReferencedTypes);
+    log.info(`Found ${result.length} referenced content types`, this.exportQueryConfig.context);
+    return result;
+  }
+
+  /**
+   * Filter content types to get only newly fetched ones based on UIDs
+   */
+  filterNewlyFetchedContentTypes(allContentTypes: any[], previousUIDs: Set<string>): any[] {
+    return allContentTypes.filter((ct) => !previousUIDs.has(ct.uid));
+  }
+
+  /**
+   * Extract referenced content types from a content type schema
+   * Moved from content-type-helper.ts for better encapsulation
+   */
+  private getReferencedContentTypes(schema: any): string[] {
+    const referencedTypes: Set<string> = new Set();
+
+    const traverseSchema = (schemaArray: any[]) => {
+      for (const field of schemaArray) {
+        if (field.data_type === 'group' || field.data_type === 'global_field') {
+          // Recursively traverse group and global field schemas.
+          // field.schema may be absent when a global_field is represented only by
+          // its reference_to UID (stub form in a content type's inline schema).
+          if (Array.isArray(field.schema) && field.schema.length > 0) {
+            traverseSchema(field.schema);
+          }
+        } else if (field.data_type === 'blocks') {
+          // Traverse each block's schema
+          for (const blockKey in field.blocks) {
+            if (field.blocks[blockKey]?.schema) {
+              traverseSchema(field.blocks[blockKey].schema);
+            }
+          }
+        } else if (field.data_type === 'reference' && field.reference_to) {
+          // Add reference field targets
+          field.reference_to.forEach((ref: string) => {
+            if (ref !== 'sys_assets') {
+              // Exclude system assets
+              referencedTypes.add(ref);
+            }
+          });
+        } else if (
+          // Handle JSON RTE with embedded entries
+          field.data_type === 'json' &&
+          field.field_metadata?.rich_text_type &&
+          field.field_metadata?.embed_entry &&
+          field.reference_to
+        ) {
+          field.reference_to.forEach((ref: string) => {
+            if (ref !== 'sys_assets') {
+              referencedTypes.add(ref);
+            }
+          });
+        } else if (
+          // Handle Text RTE with embedded entries
+          field.data_type === 'text' &&
+          field.field_metadata?.rich_text_type &&
+          field.field_metadata?.embed_entry &&
+          field.reference_to
+        ) {
+          field.reference_to.forEach((ref: string) => {
+            if (ref !== 'sys_assets') {
+              referencedTypes.add(ref);
+            }
+          });
+        }
+      }
+    };
+
+    traverseSchema(schema);
+    return Array.from(referencedTypes);
+  }
+}
diff --git a/packages/contentstack-query-export/src/utils/dependency-resolver.ts b/packages/contentstack-query-export/src/utils/dependency-resolver.ts
new file mode 100644
index 000000000..c0c63741b
--- /dev/null
+++ b/packages/contentstack-query-export/src/utils/dependency-resolver.ts
@@ -0,0 +1,190 @@
+import * as path from 'path';
+import { QueryExportConfig } from '../types';
+import { fsUtil } from './index';
+import {
+  ContentstackClient,
+  sanitizePath,
+  log,
+  formatError,
+  handleAndLogError,
+  readContentTypeSchemas,
+} from '@contentstack/cli-utilities';
+
+export class ContentTypeDependenciesHandler {
+  private exportQueryConfig: QueryExportConfig;
+  private stackAPIClient: ReturnType<ContentstackClient['stack']>;
+
+  constructor(stackAPIClient: any, exportQueryConfig: QueryExportConfig) {
+    this.exportQueryConfig = exportQueryConfig;
+    this.stackAPIClient = stackAPIClient;
+  }
+
+  /**
+   * Extract all dependencies (global fields, extensions, taxonomies, marketplace apps) from the
+   * provided schema documents.  When `schemas` is omitted the method falls back to reading content
+   * type schemas from disk — kept for backward compatibility with callers that do not supply
+   * already-loaded documents.
+   *
+   * Pass the combined set of content-type AND global-field documents so that transitive
+   * dependencies inside global fields are discovered in the same pass.
+   */
+  async extractDependencies(schemas?: any[]): Promise<{
+    globalFields: Set<string>;
+    extensions: Set<string>;
+    taxonomies: Set<string>;
+    marketplaceApps: Set<string>;
+  }> {
+    let allSchemas: any[];
+
+    if (schemas !== undefined) {
+      allSchemas = schemas;
+    } else {
+      const contentTypesFilePath = path.join(
+        sanitizePath(this.exportQueryConfig.exportDir),
+        sanitizePath(this.exportQueryConfig.branchName || ''),
+        'content_types',
+      );
+      allSchemas = readContentTypeSchemas(contentTypesFilePath);
+    }
+
+    if (allSchemas.length === 0) {
+      log.info('No schemas found, skipping dependency extraction', this.exportQueryConfig.context);
+      return {
+        globalFields: new Set<string>(),
+        extensions: new Set<string>(),
+        taxonomies: new Set<string>(),
+        marketplaceApps: new Set<string>(),
+      };
+    }
+
+    log.info(`Extracting dependencies from ${allSchemas.length} schema(s)`, this.exportQueryConfig.context);
+
+    const dependencies = {
+      globalFields: new Set<string>(),
+      extensions: new Set<string>(),
+      taxonomies: new Set<string>(),
+      marketplaceApps: new Set<string>(),
+    };
+
+    for (const doc of allSchemas) {
+      if (doc.schema) {
+        this.traverseSchemaForDependencies(doc.schema, dependencies);
+      }
+    }
+
+    // Separate extensions from marketplace apps using the extracted extension UIDs
+    if (dependencies.extensions.size > 0) {
+      const extensionUIDs = Array.from(dependencies.extensions);
+      log.info(
+        `Processing ${extensionUIDs.length} extensions to identify marketplace apps...`,
+        this.exportQueryConfig.context,
+      );
+
+      try {
+        const { extensions, marketplaceApps } = await this.fetchExtensionsAndMarketplaceApps(extensionUIDs);
+        dependencies.extensions = new Set(extensions);
+        dependencies.marketplaceApps = new Set(marketplaceApps);
+        log.info(
+          `Dependencies separated - Global Fields: ${dependencies.globalFields.size}, Extensions: ${dependencies.extensions.size}, Taxonomies: ${dependencies.taxonomies.size}, Marketplace Apps: ${dependencies.marketplaceApps.size}`,
+          this.exportQueryConfig.context,
+        );
+      } catch (error) {
+        handleAndLogError(error, this.exportQueryConfig.context, 'Failed to separate extensions and Marketplace apps');
+        // Keep original extensions if separation fails
+      }
+    } else {
+      log.info(
+        `Found dependencies - Global Fields: ${dependencies.globalFields.size}, Extensions: ${dependencies.extensions.size}, Taxonomies: ${dependencies.taxonomies.size}, Marketplace Apps: ${dependencies.marketplaceApps.size}`,
+        this.exportQueryConfig.context,
+      );
+    }
+
+    return dependencies;
+  }
+
+  // Update the fetchExtensionsAndMarketplaceApps method to only fetch specific extension UIDs
+  async fetchExtensionsAndMarketplaceApps(
+    extensionUIDs: string[],
+  ): Promise<{ extensions: string[]; marketplaceApps: string[] }> {
+    log.info(
+      `Fetching details for ${extensionUIDs.length} extensions to identify marketplace apps...`,
+      this.exportQueryConfig.context,
+    );
+
+    try {
+      // Query parameters to include marketplace extensions
+      const queryParams = {
+        include_count: true,
+        include_marketplace_extensions: true,
+        query: {
+          uid: { $in: extensionUIDs },
+        },
+      };
+
+      // Fetch all extensions including marketplace apps
+      const response = await this.stackAPIClient.extension().query(queryParams).find();
+
+      if (!response || !response.items) {
+        log.warn(`No extensions found`, this.exportQueryConfig.context);
+        return { extensions: extensionUIDs, marketplaceApps: [] };
+      }
+
+      const marketplaceApps: string[] = [];
+      const regularExtensions: string[] = [];
+
+      response.items.forEach((item: any) => {
+        if (item.app_uid && item.app_installation_uid) {
+          marketplaceApps.push(item.app_installation_uid);
+        } else {
+          regularExtensions.push(item.uid);
+        }
+      });
+
+      log.info(
+        `Identified ${marketplaceApps.length} marketplace apps and ${regularExtensions.length} regular extensions from ${extensionUIDs.length} total extensions`,
+        this.exportQueryConfig.context,
+      );
+
+      return { extensions: regularExtensions, marketplaceApps };
+    } catch (error) {
+      handleAndLogError(error, this.exportQueryConfig.context, 'Failed to fetch extensions and Marketplace apps');
+      return { extensions: extensionUIDs, marketplaceApps: [] };
+    }
+  }
+
+  private traverseSchemaForDependencies(schema: any[], dependencies: any): void {
+    for (const field of schema) {
+      // Global fields
+      if (field.data_type === 'global_field' && field.reference_to) {
+        dependencies.globalFields.add(field.reference_to);
+      }
+
+      // Extensions
+      if (field.extension_uid) {
+        dependencies.extensions.add(field.extension_uid);
+      }
+
+      // Taxonomies - UPDATED LOGIC
+      if (field.data_type === 'taxonomy' && field.taxonomies && Array.isArray(field.taxonomies)) {
+        field.taxonomies.forEach((tax: any) => {
+          if (tax.taxonomy_uid) {
+            dependencies.taxonomies.add(tax.taxonomy_uid);
+          }
+        });
+      }
+
+      // Recursive traversal for nested structures
+      if ((field.data_type === 'group' || field.data_type === 'global_field') && field.schema) {
+        this.traverseSchemaForDependencies(field.schema, dependencies);
+      }
+
+      if (field.data_type === 'blocks' && field.blocks) {
+        for (const blockKey in field.blocks) {
+          if (field.blocks[blockKey].schema) {
+            this.traverseSchemaForDependencies(field.blocks[blockKey].schema, dependencies);
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/packages/contentstack-query-export/src/utils/file-helper.ts b/packages/contentstack-query-export/src/utils/file-helper.ts
new file mode 100644
index 000000000..7aa8c6323
--- /dev/null
+++ b/packages/contentstack-query-export/src/utils/file-helper.ts
@@ -0,0 +1,2 @@
+import { FsUtility, sanitizePath } from '@contentstack/cli-utilities';
+export const fsUtil = new FsUtility();
diff --git a/packages/contentstack-query-export/src/utils/index.ts b/packages/contentstack-query-export/src/utils/index.ts
new file mode 100644
index 000000000..0687cbddc
--- /dev/null
+++ b/packages/contentstack-query-export/src/utils/index.ts
@@ -0,0 +1,10 @@
+export * as fileHelper from './file-helper';
+export { fsUtil } from './file-helper';
+export { log, unlinkFileLogger, createLogContext } from './logger';
+export { LogContext } from '../types';
+export * from './common-helper';
+export * from './config-handler';
+export * from './content-type-helper';
+export * from './dependency-resolver';
+export * from './referenced-asset-handler';
+export { setupBranches } from './branch-helper';
diff --git a/packages/contentstack-query-export/src/utils/logger.ts b/packages/contentstack-query-export/src/utils/logger.ts
new file mode 100644
index 000000000..9be2a2fe2
--- /dev/null
+++ b/packages/contentstack-query-export/src/utils/logger.ts
@@ -0,0 +1,184 @@
+/*!
+ * Contentstack Export
+ * Copyright (c) 2024 Contentstack LLC
+ * MIT Licensed
+ */
+
+import * as winston from 'winston';
+import * as path from 'path';
+import mkdirp from 'mkdirp';
+import { QueryExportConfig, LogContext } from '../types';
+import { sanitizePath, redactObject, configHandler } from '@contentstack/cli-utilities';
+const slice = Array.prototype.slice;
+
+const ansiRegexPattern = [
+  '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+  '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))',
+].join('|');
+
+function returnString(args: unknown[]) {
+  let returnStr = '';
+  if (args && args.length) {
+    returnStr = args
+      .map(function (item) {
+        if (item && typeof item === 'object') {
+          try {
+            const redactedObject = redactObject(item);
+            if (redactedObject && typeof redactedObject === 'object') {
+              return JSON.stringify(redactedObject);
+            }
+          } catch (error) {}
+          return item;
+        }
+        return item;
+      })
+      .join('  ')
+      .trim();
+  }
+  returnStr = returnStr.replace(new RegExp(ansiRegexPattern, 'g'), '').trim();
+  return returnStr;
+}
+const myCustomLevels = {
+  levels: {
+    warn: 1,
+    info: 2,
+    debug: 3,
+  },
+  colors: {
+    //colors aren't being used anywhere as of now, we're using chalk to add colors while logging
+    info: 'blue',
+    debug: 'green',
+    warn: 'yellow',
+    error: 'red',
+  },
+};
+
+let logger: winston.Logger;
+let errorLogger: winston.Logger;
+
+let successTransport;
+let errorTransport;
+
+function init(_logPath: string) {
+  if (!logger || !errorLogger) {
+    const logsDir = path.resolve(sanitizePath(_logPath), 'logs', 'export');
+    // Create dir if doesn't already exist
+    mkdirp.sync(logsDir);
+
+    successTransport = {
+      filename: path.join(sanitizePath(logsDir), 'success.log'),
+      maxFiles: 20,
+      maxsize: 1000000,
+      tailable: true,
+      level: 'info',
+    };
+
+    errorTransport = {
+      filename: path.join(sanitizePath(logsDir), 'error.log'),
+      maxFiles: 20,
+      maxsize: 1000000,
+      tailable: true,
+      level: 'error',
+    };
+
+    logger = winston.createLogger({
+      transports: [
+        new winston.transports.File(successTransport),
+        new winston.transports.Console({ format: winston.format.simple() }),
+      ],
+      levels: myCustomLevels.levels,
+    });
+
+    errorLogger = winston.createLogger({
+      transports: [
+        new winston.transports.File(errorTransport),
+        new winston.transports.Console({
+          level: 'error',
+          format: winston.format.combine(
+            winston.format.colorize({ all: true, colors: { error: 'red' } }),
+            winston.format.simple(),
+          ),
+        }),
+      ],
+      levels: { error: 0 },
+    });
+  }
+
+  return {
+    log: function (message: any) {
+      const args = slice.call(arguments);
+      const logString = returnString(args);
+      if (logString) {
+        logger.log('info', logString);
+      }
+    },
+    warn: function () {
+      const args = slice.call(arguments);
+      const logString = returnString(args);
+      if (logString) {
+        logger.log('warn', logString);
+      }
+    },
+    error: function (message: any) {
+      const args = slice.call(arguments);
+      const logString = returnString(args);
+      if (logString) {
+        errorLogger.log('error', logString);
+      }
+    },
+    debug: function () {
+      const args = slice.call(arguments);
+      const logString = returnString(args);
+      if (logString) {
+        logger.log('debug', logString);
+      }
+    },
+  };
+}
+
+export const log = async (config: QueryExportConfig, message: any, type: string) => {
+  const logsPath = sanitizePath(config.logsPath || config.dataPath);
+  // ignoring the type argument, as we are not using it to create a logfile anymore
+  if (type !== 'error') {
+    // removed type argument from init method
+    init(logsPath).log(message);
+  } else {
+    init(logsPath).error(message);
+  }
+};
+
+export const unlinkFileLogger = () => {
+  if (logger) {
+    const transports = logger.transports;
+    transports.forEach((transport: any) => {
+      if (transport.name === 'file') {
+        logger.remove(transport);
+      }
+    });
+  }
+
+  if (errorLogger) {
+    const transports = errorLogger.transports;
+    transports.forEach((transport: any) => {
+      if (transport.name === 'file') {
+        errorLogger.remove(transport);
+      }
+    });
+  }
+};
+
+/**
+ * Creates a context object for logging from QueryExportConfig
+ */
+export function createLogContext(config: QueryExportConfig, moduleName?: string): LogContext {
+  return {
+    command: 'cm:stacks:export-query',
+    module: moduleName || '',
+    email: configHandler.get('email') || '',
+    sessionId: configHandler.get('sessionId') || '',
+    apiKey: config.stackApiKey || '',
+    orgId: configHandler.get('oauthOrgUid') || '',
+    authenticationMethod: config.managementToken ? 'Management Token' : 'Basic Auth',
+  };
+}
+
diff --git a/packages/contentstack-query-export/src/utils/query-parser.ts b/packages/contentstack-query-export/src/utils/query-parser.ts
new file mode 100644
index 000000000..752a7fb8a
--- /dev/null
+++ b/packages/contentstack-query-export/src/utils/query-parser.ts
@@ -0,0 +1,66 @@
+import * as fs from 'fs';
+import { CLIError, handleAndLogError } from '@contentstack/cli-utilities';
+import { QueryExportConfig } from '../types';
+
+export class QueryParser {
+  private config: QueryExportConfig;
+
+  constructor(config: QueryExportConfig) {
+    this.config = config;
+  }
+
+  async parse(queryInput: string): Promise<any> {
+    let query: any;
+
+    // Check if it's a file path
+    if (queryInput.endsWith('.json') && fs.existsSync(queryInput)) {
+      query = this.parseFromFile(queryInput);
+    } else {
+      query = this.parseFromString(queryInput);
+    }
+
+    this.validate(query);
+    return query;
+  }
+
+  private parseFromFile(filePath: string): any {
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      return JSON.parse(content);
+    } catch (error) {
+      handleAndLogError(error, this.config.context, 'Failed to parse the query file');
+    }
+  }
+
+  private parseFromString(queryString: string): any {
+    try {
+      return JSON.parse(queryString);
+    } catch (error) {
+      handleAndLogError(error, this.config.context, 'Invalid JSON query');
+      throw new CLIError('Invalid JSON query');
+    }
+  }
+
+  private validate(query: any): void {
+    if (!query || typeof query !== 'object') {
+      throw new CLIError('The query must be a valid JSON object.');
+    }
+
+    if (!query.modules || typeof query.modules !== 'object') {
+      throw new CLIError('The query must contain a "modules" object.');
+    }
+
+    const modules = Object.keys(query.modules);
+    if (modules.length === 0) {
+      throw new CLIError('The query must contain at least one module.');
+    }
+
+    // Validate supported modules
+    const queryableModules = this.config.modules.queryable;
+    for (const module of modules) {
+      if (!queryableModules.includes(module as any)) {
+        throw new CLIError(`Module "${module}" is not queryable. Supported modules: ${queryableModules.join(', ')}`);
+      }
+    }
+  }
+}
diff --git a/packages/contentstack-query-export/src/utils/referenced-asset-handler.ts b/packages/contentstack-query-export/src/utils/referenced-asset-handler.ts
new file mode 100644
index 000000000..247b15048
--- /dev/null
+++ b/packages/contentstack-query-export/src/utils/referenced-asset-handler.ts
@@ -0,0 +1,157 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import { QueryExportConfig } from '../types';
+import { fsUtil } from './index';
+import { sanitizePath, log, formatError, handleAndLogError } from '@contentstack/cli-utilities';
+
+export class AssetReferenceHandler {
+  private exportQueryConfig: QueryExportConfig;
+  private entriesDir: string;
+
+  constructor(exportQueryConfig: QueryExportConfig) {
+    this.exportQueryConfig = exportQueryConfig;
+    this.entriesDir = path.join(
+      sanitizePath(exportQueryConfig.exportDir),
+      sanitizePath(exportQueryConfig.branchName || ''),
+      'entries',
+    );
+  }
+
+  /**
+   * Extract all asset UIDs by processing entries file by file (memory efficient)
+   */
+  extractReferencedAssets(): string[] {
+    log.info('Extracting referenced assets from entries...', this.exportQueryConfig.context);
+
+    try {
+      if (!fs.existsSync(this.entriesDir)) {
+        log.warn('Entries directory does not exist', this.exportQueryConfig.context);
+        return [];
+      }
+
+      // Global set to maintain unique asset UIDs across all files
+      const globalAssetUIDs = new Set<string>();
+
+      // Get all JSON files
+      const jsonFiles = this.findAllJsonFiles(this.entriesDir);
+
+      // Process files one by one
+      let totalEntriesProcessed = 0;
+      for (const jsonFile of jsonFiles) {
+        const entriesInFile = this.processSingleFile(jsonFile, globalAssetUIDs);
+        totalEntriesProcessed += entriesInFile;
+      }
+
+      const result = Array.from(globalAssetUIDs);
+      log.info(
+        `Found ${result.length} unique asset UIDs from ${totalEntriesProcessed} entries across ${jsonFiles.length} files`,
+        this.exportQueryConfig.context,
+      );
+
+      return result;
+    } catch (error) {
+      handleAndLogError(error, this.exportQueryConfig.context, 'Failed to extract assets');
+      return [];
+    }
+  }
+
+  /**
+   * Process a single file and extract asset UIDs from all its entries
+   */
+  private processSingleFile(filePath: string, globalAssetUIDs: Set<string>): number {
+    // Skip index.json files
+    if (path.basename(filePath) === 'index.json') {
+      return 0;
+    }
+
+    try {
+      const fileContent = fsUtil.readFile(sanitizePath(filePath));
+
+      if (!fileContent || typeof fileContent !== 'object') {
+        return 0;
+      }
+
+      // Stringify the ENTIRE file content at once
+      const fileString = JSON.stringify(fileContent);
+
+      // Extract all asset UIDs from the entire file
+      const assetUIDs = this.extractAssetUIDsFromString(fileString);
+
+      // Add to global set
+      assetUIDs.forEach((uid) => globalAssetUIDs.add(uid));
+
+      // Count entries for logging
+      const entriesCount = Object.keys(fileContent).length;
+      log.debug(`Processed ${entriesCount} entries from ${path.basename(filePath)}`, this.exportQueryConfig.context);
+
+      return entriesCount;
+    } catch (error) {
+      log.warn(`Failed to process file ${filePath}: ${formatError(error)}`, this.exportQueryConfig.context);
+      return 0;
+    }
+  }
+
+  /**
+   * Extract asset UIDs from stringified content using multiple patterns
+   */
+  private extractAssetUIDsFromString(content: string): string[] {
+    const assetUIDs = new Set<string>();
+
+    // Pattern 1: HTML img tags with asset_uid
+    const htmlAssetRegex = /<img asset_uid=\\"([^"]+)\\"/g;
+    let match;
+    while ((match = htmlAssetRegex.exec(content)) !== null) {
+      if (match[1]) {
+        assetUIDs.add(match[1]);
+      }
+    }
+
+    let assetUrlRegex = '';
+    let assetUIDMatchIndex;
+    if (process.env.ENVIRONMENT === 'NON_PROD') {
+      assetUrlRegex = '(https://.*?/v3/assets/(.*?)/(.*?)/(.*?)/(.*?)(?="))';
+      assetUIDMatchIndex = 3;
+    } else {
+      assetUrlRegex =
+        '(https://(assets|(eu-|azure-na-|azure-eu-|gcp-na-|gcp-eu-)?images).contentstack.(io|com)/v3/assets/(.*?)/(.*?)/(.*?)/(.*?)(?="))';
+      assetUIDMatchIndex = 6;
+    }
+
+    // Pattern 2: Contentstack asset URLs
+    const urlRegex = new RegExp(assetUrlRegex, 'g');
+    while ((match = urlRegex.exec(content)) !== null) {
+      const assetUID = match[assetUIDMatchIndex]; // The asset UID is in the 6th capture group
+      if (assetUID) {
+        assetUIDs.add(assetUID);
+      }
+    }
+
+    return Array.from(assetUIDs);
+  }
+
+  /**
+   * Recursively find all JSON files in the entries directory
+   */
+  private findAllJsonFiles(dir: string): string[] {
+    const jsonFiles: string[] = [];
+
+    try {
+      const items = fs.readdirSync(dir);
+
+      for (const item of items) {
+        const fullPath = path.join(dir, item);
+        const stat = fs.statSync(fullPath);
+
+        if (stat.isDirectory()) {
+          jsonFiles.push(...this.findAllJsonFiles(fullPath));
+        } else if (stat.isFile() && item.endsWith('.json')) {
+          jsonFiles.push(fullPath);
+        }
+      }
+    } catch (error) {
+      log.warn(`Failed to read directory ${dir}: ${formatError(error)}`, this.exportQueryConfig.context);
+    }
+
+    return jsonFiles;
+  }
+}
diff --git a/packages/contentstack-query-export/test-export/main/assets/assets.json b/packages/contentstack-query-export/test-export/main/assets/assets.json
new file mode 100644
index 000000000..9e26dfeeb
--- /dev/null
+++ b/packages/contentstack-query-export/test-export/main/assets/assets.json
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/packages/contentstack-query-export/test-export/main/assets/metadata.json b/packages/contentstack-query-export/test-export/main/assets/metadata.json
new file mode 100644
index 000000000..9e26dfeeb
--- /dev/null
+++ b/packages/contentstack-query-export/test-export/main/assets/metadata.json
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/packages/contentstack-query-export/test/config.json b/packages/contentstack-query-export/test/config.json
new file mode 100644
index 000000000..16fa0f835
--- /dev/null
+++ b/packages/contentstack-query-export/test/config.json
@@ -0,0 +1,8 @@
+{
+  "IS_TS": false,
+  "UNIT_EXECUTION_ORDER": [],
+  "INTEGRATION_EXECUTION_ORDER": [],
+  "ENABLE_PREREQUISITES": true,
+  "REGIONS": ["AWS-NA", "AWS-EU", "AZURE-NA", "AZURE-EU"],
+  "apiKey": "***REMOVED***"
+}
diff --git a/packages/contentstack-query-export/test/helpers/init.js b/packages/contentstack-query-export/test/helpers/init.js
new file mode 100644
index 000000000..338e715a2
--- /dev/null
+++ b/packages/contentstack-query-export/test/helpers/init.js
@@ -0,0 +1,6 @@
+const path = require('path')
+process.env.TS_NODE_PROJECT = path.resolve('test/tsconfig.json')
+process.env.NODE_ENV = 'development'
+
+global.oclif = global.oclif || {}
+global.oclif.columns = 80
diff --git a/packages/contentstack-query-export/test/tsconfig.json b/packages/contentstack-query-export/test/tsconfig.json
new file mode 100644
index 000000000..9c8a8b6dd
--- /dev/null
+++ b/packages/contentstack-query-export/test/tsconfig.json
@@ -0,0 +1,12 @@
+{
+  "extends": "../tsconfig",
+  "compilerOptions": {
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "es2019",
+    "skipLibCheck": true,
+    "strict": false
+  }
+}
diff --git a/packages/contentstack-query-export/test/unit/common-helper.test.ts b/packages/contentstack-query-export/test/unit/common-helper.test.ts
new file mode 100644
index 000000000..b1cb3b298
--- /dev/null
+++ b/packages/contentstack-query-export/test/unit/common-helper.test.ts
@@ -0,0 +1,73 @@
+import { expect } from 'chai';
+import { stub, restore, SinonStub } from 'sinon';
+import { cliux } from '@contentstack/cli-utilities';
+import { askAPIKey } from '../../src/utils/common-helper';
+
+describe('Common Helper Utilities', () => {
+  let cliuxInquireStub: SinonStub;
+
+  beforeEach(() => {
+    restore();
+  });
+
+  afterEach(() => {
+    restore();
+  });
+
+  describe('askAPIKey', () => {
+    it('should prompt user for API key and return the response', async () => {
+      const mockApiKey = 'test-api-key-12345';
+
+      cliuxInquireStub = stub(cliux, 'inquire').resolves(mockApiKey);
+
+      const result = await askAPIKey();
+
+      expect(result).to.equal(mockApiKey);
+      expect(cliuxInquireStub.calledOnce).to.be.true;
+
+      const callArgs = cliuxInquireStub.firstCall.args[0];
+      expect(callArgs.type).to.equal('input');
+      expect(callArgs.message).to.equal('Enter the stack api key');
+      expect(callArgs.name).to.equal('apiKey');
+    });
+
+    it('should handle empty API key input', async () => {
+      const emptyApiKey = '';
+
+      cliuxInquireStub = stub(cliux, 'inquire').resolves(emptyApiKey);
+
+      const result = await askAPIKey();
+
+      expect(result).to.equal(emptyApiKey);
+      expect(cliuxInquireStub.calledOnce).to.be.true;
+    });
+
+    it('should handle inquire errors', async () => {
+      const error = new Error('Inquire failed');
+
+      cliuxInquireStub = stub(cliux, 'inquire').rejects(error);
+
+      try {
+        await askAPIKey();
+        expect.fail('Expected an error to be thrown');
+      } catch (err) {
+        expect(err.message).to.equal('Inquire failed');
+      }
+    });
+
+    it('should validate the inquire call structure', async () => {
+      const mockApiKey = 'valid-api-key';
+
+      cliuxInquireStub = stub(cliux, 'inquire').resolves(mockApiKey);
+
+      await askAPIKey();
+
+      expect(cliuxInquireStub.calledOnce).to.be.true;
+
+      const inquireOptions = cliuxInquireStub.firstCall.args[0];
+      expect(inquireOptions).to.have.property('type', 'input');
+      expect(inquireOptions).to.have.property('message', 'Enter the stack api key');
+      expect(inquireOptions).to.have.property('name', 'apiKey');
+    });
+  });
+});
diff --git a/packages/contentstack-query-export/test/unit/config-handler.test.ts b/packages/contentstack-query-export/test/unit/config-handler.test.ts
new file mode 100644
index 000000000..bb4cb45c5
--- /dev/null
+++ b/packages/contentstack-query-export/test/unit/config-handler.test.ts
@@ -0,0 +1,349 @@
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import * as path from 'path';
+import { setupQueryExportConfig } from '../../src/utils/config-handler';
+import * as commonHelper from '../../src/utils/common-helper';
+
+// Mock the external utilities module
+const mockCliUtilities = {
+  sanitizePath: sinon.stub(),
+  pathValidator: sinon.stub(),
+  configHandler: {
+    get: sinon.stub(),
+  },
+  isAuthenticated: sinon.stub(),
+};
+
+describe('Config Handler', () => {
+  let sandbox: sinon.SinonSandbox;
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox();
+
+    // Set up default mock behavior to avoid interactive prompts
+    mockCliUtilities.sanitizePath.returns('./mocked-export-dir');
+    mockCliUtilities.pathValidator.returns('./mocked-path');
+    mockCliUtilities.configHandler.get.returns(null);
+    mockCliUtilities.isAuthenticated.returns(false); // Default to not authenticated to avoid prompts
+
+    // Stub our own helper to prevent prompts
+    sandbox.stub(commonHelper, 'askAPIKey').resolves('mocked-api-key');
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+    // Reset mock stubs
+    mockCliUtilities.sanitizePath.reset();
+    mockCliUtilities.pathValidator.reset();
+    mockCliUtilities.configHandler.get.reset();
+    mockCliUtilities.isAuthenticated.reset();
+  });
+
+  describe('setupQueryExportConfig', () => {
+    describe('with minimal flags', () => {
+      it('should create config with default values', async () => {
+        const flags = {
+          query: 'content_type_uid:page',
+          'stack-api-key': 'test-stack-api-key', // Provide API key to avoid prompts
+        };
+
+        try {
+          const config = await setupQueryExportConfig(flags);
+
+          expect(config).to.be.an('object');
+          expect(config.query).to.equal('content_type_uid:page');
+          expect(config.skipReferences).to.be.false;
+          expect(config.skipDependencies).to.be.false;
+          expect(config.securedAssets).to.be.false;
+          expect(config.isQueryBasedExport).to.be.true;
+          expect(config.stackApiKey).to.equal('test-stack-api-key');
+          expect(config.exportDir).to.be.a('string');
+          expect(config.logsPath).to.be.a('string');
+          expect(config.dataPath).to.be.a('string');
+          expect(config.externalConfigPath).to.include('export-config.json');
+        } catch (error) {
+          // May fail due to other authentication requirements, but not API key prompts
+          expect(error).to.be.an('error');
+        }
+      });
+    });
+
+    describe('with custom data directory', () => {
+      it('should use custom data directory when provided', async () => {
+        const flags = {
+          'data-dir': './custom-export',
+          query: 'content_type_uid:blog',
+          'stack-api-key': 'test-stack-key',
+        };
+
+        try {
+          const config = await setupQueryExportConfig(flags);
+          expect(config.exportDir).to.be.a('string').and.include('custom-export');
+          expect(config.logsPath).to.be.a('string').and.include('custom-export');
+          expect(config.dataPath).to.be.a('string').and.include('custom-export');
+        } catch (error) {
+          // May fail due to authentication, but we can test the flag handling
+          expect(flags['data-dir']).to.equal('./custom-export');
+        }
+      });
+    });
+
+    describe('with skip flags', () => {
+      it('should set skip flags when provided', async () => {
+        const flags = {
+          query: 'content_type_uid:article',
+          'skip-references': true,
+          'skip-dependencies': true,
+          'secured-assets': true,
+          'stack-api-key': 'test-stack-api-key', // Provide API key to avoid prompts
+        };
+
+        try {
+          const config = await setupQueryExportConfig(flags);
+          expect(config.skipReferences).to.be.true;
+          expect(config.skipDependencies).to.be.true;
+          expect(config.securedAssets).to.be.true;
+        } catch (error) {
+          // Test flag mapping even if authentication fails
+          expect(flags['skip-references']).to.be.true;
+          expect(flags['skip-dependencies']).to.be.true;
+          expect(flags['secured-assets']).to.be.true;
+        }
+      });
+    });
+
+    describe('with branch name', () => {
+      it('should include branch name when provided', async () => {
+        const flags = {
+          query: 'content_type_uid:news',
+          branch: 'development',
+          'stack-api-key': 'test-stack-api-key', // Provide API key to avoid prompts
+        };
+
+        try {
+          const config = await setupQueryExportConfig(flags);
+          expect(config.branchName).to.equal('development');
+        } catch (error) {
+          // Test branch assignment
+          expect(flags.branch).to.equal('development');
+        }
+      });
+    });
+
+    describe('external config path', () => {
+      it('should set external config path correctly', async () => {
+        const flags = {
+          query: 'content_type_uid:test',
+          'stack-api-key': 'test-stack-api-key', // Provide API key to avoid prompts
+        };
+
+        try {
+          const config = await setupQueryExportConfig(flags);
+          expect(config.externalConfigPath).to.be.a('string').and.include('export-config.json');
+          expect(path.isAbsolute(config.externalConfigPath || '')).to.be.true;
+        } catch (error) {
+          // Test path construction logic
+          const expectedPath = path.join(__dirname, '../config/export-config.json');
+          expect(expectedPath).to.include('export-config.json');
+        }
+      });
+    });
+
+    describe('stack API key handling', () => {
+      it('should use provided stack API key', async () => {
+        const flags = {
+          query: 'content_type_uid:product',
+          'stack-api-key': 'blt123456789',
+        };
+
+        try {
+          const config = await setupQueryExportConfig(flags);
+          expect(config.stackApiKey).to.equal('blt123456789');
+        } catch (error) {
+          // Verify flag is captured even if auth fails
+          expect(flags['stack-api-key']).to.equal('blt123456789');
+        }
+      });
+
+      it('should handle empty stack API key', async () => {
+        const flags = {
+          query: 'content_type_uid:empty',
+          // Intentionally not providing stack-api-key to test this scenario
+        };
+
+        try {
+          const config = await setupQueryExportConfig(flags);
+          expect(config.stackApiKey).to.be.a('string');
+        } catch (error) {
+          // Expected when not authenticated: explicit error, not an interactive prompt
+          expect(error.message).to.include('Log in');
+        }
+      });
+    });
+
+    describe('configuration object structure', () => {
+      it('should include all required configuration properties', async () => {
+        const flags = {
+          query: 'content_type_uid:structure_test',
+          'stack-api-key': 'test-key',
+        };
+
+        try {
+          const config = await setupQueryExportConfig(flags);
+
+          // Test required properties exist
+          expect(config).to.have.property('exportDir');
+          expect(config).to.have.property('stackApiKey');
+          expect(config).to.have.property('query');
+          expect(config).to.have.property('skipReferences');
+          expect(config).to.have.property('skipDependencies');
+          expect(config).to.have.property('securedAssets');
+          expect(config).to.have.property('isQueryBasedExport');
+          expect(config).to.have.property('logsPath');
+          expect(config).to.have.property('dataPath');
+          expect(config).to.have.property('externalConfigPath');
+
+          // Test property types
+          expect(config.exportDir).to.be.a('string');
+          expect(config.stackApiKey).to.be.a('string');
+          expect(config.query).to.be.a('string');
+          expect(config.skipReferences).to.be.a('boolean');
+          expect(config.skipDependencies).to.be.a('boolean');
+          expect(config.securedAssets).to.be.a('boolean');
+          expect(config.isQueryBasedExport).to.be.a('boolean');
+          expect(config.logsPath).to.be.a('string');
+          expect(config.dataPath).to.be.a('string');
+          expect(config.externalConfigPath).to.be.a('string');
+        } catch (error) {
+          // Test flag structure even if config creation fails
+          expect(flags).to.have.property('query');
+          expect(flags.query).to.be.a('string');
+        }
+      });
+
+      it('should set isQueryBasedExport to true', async () => {
+        const flags = {
+          query: 'content_type_uid:query_based',
+          'stack-api-key': 'test-stack-api-key', // Provide API key to avoid prompts
+        };
+
+        try {
+          const config = await setupQueryExportConfig(flags);
+          expect(config.isQueryBasedExport).to.be.true;
+        } catch (error) {
+          // This property should always be true for query-based exports
+          expect(true).to.be.true; // Placeholder assertion
+        }
+      });
+    });
+
+    describe('error scenarios', () => {
+      it('should handle missing query parameter', async () => {
+        const flags = {
+          'stack-api-key': 'test-stack-api-key', // Provide API key to avoid prompts
+        };
+
+        try {
+          const config = await setupQueryExportConfig(flags);
+          expect(config.query).to.be.undefined;
+        } catch (error) {
+          // Query might be required, test error handling
+          expect(error).to.be.an('error');
+        }
+      });
+
+      it('should handle invalid flag types', async () => {
+        const flags = {
+          query: 123, // Invalid type
+          'skip-references': 'not-boolean',
+          'stack-api-key': 'test-stack-api-key', // Provide API key to avoid prompts
+        };
+
+        try {
+          const config = await setupQueryExportConfig(flags);
+          // Test type coercion
+          expect(config.query).to.equal(123);
+        } catch (error) {
+          expect(error).to.be.an('error');
+        }
+      });
+    });
+
+    describe('path handling', () => {
+      it('should ensure paths are consistent', async () => {
+        const flags = {
+          query: 'content_type_uid:path_test',
+          'data-dir': './test-export',
+          'stack-api-key': 'test-stack-api-key', // Provide API key to avoid prompts
+        };
+
+        try {
+          const config = await setupQueryExportConfig(flags);
+          expect(config.exportDir).to.equal(config.logsPath);
+          expect(config.exportDir).to.equal(config.dataPath);
+          expect(config.exportDir).to.be.a('string').and.include('test-export');
+        } catch (error) {
+          // Test path consistency logic
+          expect(flags['data-dir']).to.equal('./test-export');
+        }
+      });
+
+      it('should handle absolute paths', async () => {
+        const absolutePath = path.resolve('./absolute-test');
+        const flags = {
+          query: 'content_type_uid:absolute',
+          'data-dir': absolutePath,
+          'stack-api-key': 'test-stack-api-key', // Provide API key to avoid prompts
+        };
+
+        try {
+          const config = await setupQueryExportConfig(flags);
+          expect(path.isAbsolute(config.exportDir || '')).to.be.true;
+        } catch (error) {
+          // Test absolute path handling
+          expect(path.isAbsolute(absolutePath)).to.be.true;
+        }
+      });
+    });
+
+    describe('askAPIKey integration', () => {
+      it('should call askAPIKey when no stack API key provided', async () => {
+        // This test should fail with authentication error, not call askAPIKey in our mock setup
+        const flags = {
+          query: 'content_type_uid:prompt_test',
+          // Intentionally not providing stack-api-key to test this scenario
+        };
+
+        try {
+          await setupQueryExportConfig(flags);
+          expect.fail('Should have thrown authentication error');
+        } catch (error) {
+          // Expected to fail due to authentication requirements
+          expect(error.message).to.match(/login|Please login|authentication|token/i);
+        }
+      });
+
+      it('should handle askAPIKey returning non-string value', async () => {
+        // Override the default stub to return invalid value for this specific test
+        sandbox.restore(); // Clear existing stubs
+        sandbox.stub(commonHelper, 'askAPIKey').resolves(undefined as any);
+
+        // Mock isAuthenticated to return true to trigger the askAPIKey path
+        const mockIsAuthenticated = sandbox.stub().returns(true);
+
+        const flags = {
+          query: 'content_type_uid:invalid_key',
+          // Not providing stack-api-key to trigger askAPIKey path
+        };
+
+        try {
+          await setupQueryExportConfig(flags);
+          expect.fail('Should have thrown error for invalid API key');
+        } catch (error) {
+          // Should fail due to authentication or other issues, test completed
+          expect(error).to.be.an('error');
+        }
+      });
+    });
+  });
+});
diff --git a/packages/contentstack-query-export/test/unit/content-type-helper.test.ts b/packages/contentstack-query-export/test/unit/content-type-helper.test.ts
new file mode 100644
index 000000000..60606f44e
--- /dev/null
+++ b/packages/contentstack-query-export/test/unit/content-type-helper.test.ts
@@ -0,0 +1,502 @@
+import { expect } from 'chai';
+import { stub, restore, SinonStub } from 'sinon';
+import * as path from 'path';
+import { ReferencedContentTypesHandler } from '../../src/utils/content-type-helper';
+import * as logger from '../../src/utils/logger';
+import { QueryExportConfig } from '../../src/types';
+
+describe('Content Type Helper Utilities', () => {
+  let handler: ReferencedContentTypesHandler;
+  let mockConfig: QueryExportConfig;
+  let logStub: SinonStub;
+  let pathJoinStub: SinonStub;
+
+  beforeEach(() => {
+    mockConfig = {
+      maxCTReferenceDepth: 20,
+      contentVersion: 2,
+      host: 'https://api.contentstack.io/v3',
+      exportDir: '/test/export',
+      stackApiKey: 'test-api-key',
+      managementToken: 'test-token',
+      query: '',
+      skipReferences: false,
+      skipDependencies: false,
+      branchName: 'main',
+      securedAssets: false,
+      isQueryBasedExport: true,
+      logsPath: '/test/logs',
+      dataPath: '/test/data',
+      modules: {
+        general: ['stack', 'locales', 'environments'],
+        queryable: ['content-types'],
+        dependent: ['global-fields', 'extensions', 'taxonomies'],
+        content: ['entries', 'assets'],
+        exportOrder: ['stack', 'content-types'],
+      },
+      queryConfig: {
+        maxRecursionDepth: 10,
+        batchSize: 100,
+        metadataFileName: '_query-meta.json',
+        validation: {
+          maxQueryDepth: 5,
+          maxArraySize: 1000,
+          allowedDateFormats: ['ISO8601'],
+        },
+      },
+      fetchConcurrency: 5,
+      writeConcurrency: 5,
+      apis: {
+        stacks: '/stacks/',
+        locales: '/locales/',
+        environments: '/environments/',
+        content_types: '/content_types/',
+        global_fields: '/global_fields/',
+        extensions: '/extensions/',
+        taxonomies: '/taxonomies/',
+        entries: '/entries/',
+        assets: '/assets/',
+      },
+    };
+
+    handler = new ReferencedContentTypesHandler(mockConfig);
+    restore();
+  });
+
+  afterEach(() => {
+    restore();
+  });
+
+  describe('extractReferencedContentTypes', () => {
+    it('should extract reference field targets', async () => {
+      const contentTypeBatch = [
+        {
+          uid: 'blog',
+          schema: [
+            {
+              uid: 'author',
+              data_type: 'reference',
+              reference_to: ['author', 'editor'],
+            },
+            {
+              uid: 'category',
+              data_type: 'reference',
+              reference_to: ['category'],
+            },
+          ],
+        },
+      ];
+
+      logStub = stub(logger, 'log');
+
+      const result = await handler.extractReferencedContentTypes(contentTypeBatch);
+
+      expect(result).to.deep.equal(['author', 'editor', 'category']);
+    });
+
+    it('should exclude sys_assets from references', async () => {
+      const contentTypeBatch = [
+        {
+          uid: 'blog',
+          schema: [
+            {
+              uid: 'image',
+              data_type: 'reference',
+              reference_to: ['sys_assets', 'custom_asset'],
+            },
+          ],
+        },
+      ];
+
+      logStub = stub(logger, 'log');
+
+      const result = await handler.extractReferencedContentTypes(contentTypeBatch);
+
+      expect(result).to.deep.equal(['custom_asset']);
+      expect(result).to.not.include('sys_assets');
+    });
+
+    it('should handle group fields with nested schemas', async () => {
+      const contentTypeBatch = [
+        {
+          uid: 'blog',
+          schema: [
+            {
+              uid: 'metadata',
+              data_type: 'group',
+              schema: [
+                {
+                  uid: 'author',
+                  data_type: 'reference',
+                  reference_to: ['author'],
+                },
+              ],
+            },
+          ],
+        },
+      ];
+
+      logStub = stub(logger, 'log');
+
+      const result = await handler.extractReferencedContentTypes(contentTypeBatch);
+
+      expect(result).to.deep.equal(['author']);
+    });
+
+    it('should handle global fields with nested schemas', async () => {
+      const contentTypeBatch = [
+        {
+          uid: 'blog',
+          schema: [
+            {
+              uid: 'seo',
+              data_type: 'global_field',
+              schema: [
+                {
+                  uid: 'related_page',
+                  data_type: 'reference',
+                  reference_to: ['page'],
+                },
+              ],
+            },
+          ],
+        },
+      ];
+
+      logStub = stub(logger, 'log');
+
+      const result = await handler.extractReferencedContentTypes(contentTypeBatch);
+
+      expect(result).to.deep.equal(['page']);
+    });
+
+    it('should handle blocks with nested schemas', async () => {
+      const contentTypeBatch = [
+        {
+          uid: 'page',
+          schema: [
+            {
+              uid: 'content_blocks',
+              data_type: 'blocks',
+              blocks: {
+                hero_block: {
+                  schema: [
+                    {
+                      uid: 'background_image',
+                      data_type: 'reference',
+                      reference_to: ['image_gallery'],
+                    },
+                  ],
+                },
+                testimonial_block: {
+                  schema: [
+                    {
+                      uid: 'testimonial',
+                      data_type: 'reference',
+                      reference_to: ['testimonial'],
+                    },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      ];
+
+      logStub = stub(logger, 'log');
+
+      const result = await handler.extractReferencedContentTypes(contentTypeBatch);
+
+      expect(result).to.deep.equal(['image_gallery', 'testimonial']);
+    });
+
+    it('should handle JSON RTE with embedded entries', async () => {
+      const contentTypeBatch = [
+        {
+          uid: 'article',
+          schema: [
+            {
+              uid: 'content',
+              data_type: 'json',
+              field_metadata: {
+                rich_text_type: true,
+                embed_entry: true,
+              },
+              reference_to: ['related_article', 'quote'],
+            },
+          ],
+        },
+      ];
+
+      logStub = stub(logger, 'log');
+
+      const result = await handler.extractReferencedContentTypes(contentTypeBatch);
+
+      expect(result).to.deep.equal(['related_article', 'quote']);
+    });
+
+    it('should handle Text RTE with embedded entries', async () => {
+      const contentTypeBatch = [
+        {
+          uid: 'article',
+          schema: [
+            {
+              uid: 'content',
+              data_type: 'text',
+              field_metadata: {
+                rich_text_type: true,
+                embed_entry: true,
+              },
+              reference_to: ['related_article'],
+            },
+          ],
+        },
+      ];
+
+      logStub = stub(logger, 'log');
+
+      const result = await handler.extractReferencedContentTypes(contentTypeBatch);
+
+      expect(result).to.deep.equal(['related_article']);
+    });
+
+    it('should handle content types without schemas', async () => {
+      const contentTypeBatch = [
+        {
+          uid: 'simple',
+          // No schema property
+        },
+        {
+          uid: 'with_schema',
+          schema: [
+            {
+              uid: 'reference_field',
+              data_type: 'reference',
+              reference_to: ['author'],
+            },
+          ],
+        },
+      ];
+
+      logStub = stub(logger, 'log');
+
+      const result = await handler.extractReferencedContentTypes(contentTypeBatch);
+
+      expect(result).to.deep.equal(['author']);
+    });
+
+    it('should return empty array for content types with no references', async () => {
+      const contentTypeBatch = [
+        {
+          uid: 'simple',
+          schema: [
+            {
+              uid: 'title',
+              data_type: 'text',
+            },
+            {
+              uid: 'description',
+              data_type: 'text',
+            },
+          ],
+        },
+      ];
+
+      logStub = stub(logger, 'log');
+
+      const result = await handler.extractReferencedContentTypes(contentTypeBatch);
+
+      expect(result).to.deep.equal([]);
+    });
+
+    it('should handle complex nested structures', async () => {
+      const contentTypeBatch = [
+        {
+          uid: 'complex_page',
+          schema: [
+            {
+              uid: 'sections',
+              data_type: 'group',
+              schema: [
+                {
+                  uid: 'content_blocks',
+                  data_type: 'blocks',
+                  blocks: {
+                    hero: {
+                      schema: [
+                        {
+                          uid: 'author',
+                          data_type: 'reference',
+                          reference_to: ['author'],
+                        },
+                        {
+                          uid: 'nested_group',
+                          data_type: 'group',
+                          schema: [
+                            {
+                              uid: 'category',
+                              data_type: 'reference',
+                              reference_to: ['category'],
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  },
+                },
+              ],
+            },
+          ],
+        },
+      ];
+
+      logStub = stub(logger, 'log');
+
+      const result = await handler.extractReferencedContentTypes(contentTypeBatch);
+
+      expect(result).to.deep.equal(['author', 'category']);
+    });
+
+    it('should remove duplicates from referenced content types', async () => {
+      const contentTypeBatch = [
+        {
+          uid: 'blog1',
+          schema: [
+            {
+              uid: 'author1',
+              data_type: 'reference',
+              reference_to: ['author', 'category'],
+            },
+          ],
+        },
+        {
+          uid: 'blog2',
+          schema: [
+            {
+              uid: 'author2',
+              data_type: 'reference',
+              reference_to: ['author', 'tag'],
+            },
+          ],
+        },
+      ];
+
+      logStub = stub(logger, 'log');
+
+      const result = await handler.extractReferencedContentTypes(contentTypeBatch);
+
+      expect(result).to.deep.equal(['author', 'category', 'tag']);
+      expect(result.filter((item) => item === 'author')).to.have.length(1);
+    });
+  });
+
+  describe('filterNewlyFetchedContentTypes', () => {
+    it('should filter out content types that were previously fetched', () => {
+      const allContentTypes = [
+        { uid: 'blog', title: 'Blog' },
+        { uid: 'author', title: 'Author' },
+        { uid: 'category', title: 'Category' },
+        { uid: 'tag', title: 'Tag' },
+      ];
+
+      const previousUIDs = new Set(['blog', 'category']);
+
+      const result = handler.filterNewlyFetchedContentTypes(allContentTypes, previousUIDs);
+
+      expect(result).to.deep.equal([
+        { uid: 'author', title: 'Author' },
+        { uid: 'tag', title: 'Tag' },
+      ]);
+    });
+
+    it('should return all content types when no previous UIDs', () => {
+      const allContentTypes = [
+        { uid: 'blog', title: 'Blog' },
+        { uid: 'author', title: 'Author' },
+      ];
+
+      const previousUIDs = new Set<string>();
+
+      const result = handler.filterNewlyFetchedContentTypes(allContentTypes, previousUIDs);
+
+      expect(result).to.deep.equal(allContentTypes);
+    });
+
+    it('should return empty array when all content types were previously fetched', () => {
+      const allContentTypes = [
+        { uid: 'blog', title: 'Blog' },
+        { uid: 'author', title: 'Author' },
+      ];
+
+      const previousUIDs = new Set(['blog', 'author']);
+
+      const result = handler.filterNewlyFetchedContentTypes(allContentTypes, previousUIDs);
+
+      expect(result).to.deep.equal([]);
+    });
+
+    it('should handle empty content types array', () => {
+      const allContentTypes: any[] = [];
+      const previousUIDs = new Set(['blog']);
+
+      const result = handler.filterNewlyFetchedContentTypes(allContentTypes, previousUIDs);
+
+      expect(result).to.deep.equal([]);
+    });
+  });
+
+  describe('extractReferencedContentTypes — global field and guard behaviour', () => {
+    it('should not throw when a global_field has no schema property (stub form)', async () => {
+      const batch = [
+        {
+          uid: 'page',
+          schema: [
+            {
+              uid: 'seo',
+              data_type: 'global_field',
+              reference_to: 'seo_gf',
+              // no schema array — this is the "stub" representation in a CT's inline schema
+            },
+          ],
+        },
+      ];
+
+      logStub = stub(logger, 'log');
+      const result = await handler.extractReferencedContentTypes(batch);
+      expect(result).to.deep.equal([]);
+    });
+
+    it('should find CT references inside a global field document passed directly', async () => {
+      // The caller passes both the CT doc and the GF doc in the same batch.
+      const batch = [
+        {
+          uid: 'page',
+          schema: [{ uid: 'seo', data_type: 'global_field', reference_to: 'seo_gf' }],
+        },
+        {
+          uid: 'seo_gf',
+          schema: [{ uid: 'author_ref', data_type: 'reference', reference_to: ['author'] }],
+        },
+      ];
+
+      logStub = stub(logger, 'log');
+      const result = await handler.extractReferencedContentTypes(batch);
+      expect(result).to.include('author');
+    });
+
+    it('should not recurse into global_field stub when schema is an empty array', async () => {
+      const batch = [
+        {
+          uid: 'page',
+          schema: [
+            { uid: 'seo', data_type: 'global_field', reference_to: 'seo_gf', schema: [] as any[] },
+          ],
+        },
+      ];
+
+      logStub = stub(logger, 'log');
+      const result = await handler.extractReferencedContentTypes(batch);
+      expect(result).to.deep.equal([]);
+    });
+  });
+});
diff --git a/packages/contentstack-query-export/test/unit/dependency-resolver.test.ts b/packages/contentstack-query-export/test/unit/dependency-resolver.test.ts
new file mode 100644
index 000000000..678127ae7
--- /dev/null
+++ b/packages/contentstack-query-export/test/unit/dependency-resolver.test.ts
@@ -0,0 +1,600 @@
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { ContentTypeDependenciesHandler } from '../../src/utils/dependency-resolver';
+import { QueryExportConfig } from '../../src/types';
+
+describe('Dependency Resolver Utilities', () => {
+  let handler: ContentTypeDependenciesHandler;
+  let mockConfig: QueryExportConfig;
+  let mockStackAPIClient: any;
+
+  beforeEach(() => {
+    // Create a mock stack API client
+    mockStackAPIClient = {
+      extension: sinon.stub().returns({
+        query: sinon.stub().returns({
+          find: sinon.stub().resolves({
+            items: [],
+          }),
+        }),
+      }),
+    };
+
+    mockConfig = {
+      maxCTReferenceDepth: 20,
+      contentVersion: 2,
+      host: 'https://api.contentstack.io/v3',
+      exportDir: '/test/export',
+      stackApiKey: 'test-api-key',
+      managementToken: 'test-token',
+      query: '',
+      skipReferences: false,
+      skipDependencies: false,
+      branchName: 'main',
+      securedAssets: false,
+      isQueryBasedExport: true,
+      logsPath: '/test/logs',
+      dataPath: '/test/data',
+      modules: {
+        general: ['stack', 'locales', 'environments'],
+        queryable: ['content-types'],
+        dependent: ['global-fields', 'extensions', 'taxonomies'],
+        content: ['entries', 'assets'],
+        exportOrder: ['stack', 'content-types'],
+      },
+      queryConfig: {
+        maxRecursionDepth: 10,
+        batchSize: 100,
+        metadataFileName: '_query-meta.json',
+        validation: {
+          maxQueryDepth: 5,
+          maxArraySize: 1000,
+          allowedDateFormats: ['ISO8601'],
+        },
+      },
+      fetchConcurrency: 5,
+      writeConcurrency: 5,
+      apis: {
+        stacks: '/stacks/',
+        locales: '/locales/',
+        environments: '/environments/',
+        content_types: '/content_types/',
+        global_fields: '/global_fields/',
+        extensions: '/extensions/',
+        taxonomies: '/taxonomies/',
+        entries: '/entries/',
+        assets: '/assets/',
+      },
+    };
+
+    // Fix: Pass both required arguments to the constructor
+    handler = new ContentTypeDependenciesHandler(mockStackAPIClient, mockConfig);
+  });
+
+  describe('Schema dependency extraction logic', () => {
+    it('should extract global field dependencies from schema', () => {
+      const schema = [
+        {
+          uid: 'seo',
+          data_type: 'global_field',
+          reference_to: 'seo_fields',
+        },
+        {
+          uid: 'metadata',
+          data_type: 'global_field',
+          reference_to: 'common_metadata',
+        },
+      ];
+
+      const dependencies = {
+        globalFields: new Set<string>(),
+        extensions: new Set<string>(),
+        taxonomies: new Set<string>(),
+      };
+
+      // Access private method for testing
+      (handler as any).traverseSchemaForDependencies(schema, dependencies);
+
+      expect(dependencies.globalFields.has('seo_fields')).to.be.true;
+      expect(dependencies.globalFields.has('common_metadata')).to.be.true;
+      expect(dependencies.globalFields.size).to.equal(2);
+    });
+
+    it('should extract extension dependencies from schema', () => {
+      const schema = [
+        {
+          uid: 'rich_text',
+          data_type: 'text',
+          extension_uid: 'rich_text_editor',
+        },
+        {
+          uid: 'color_picker',
+          data_type: 'text',
+          extension_uid: 'color_picker_ext',
+        },
+      ];
+
+      const dependencies = {
+        globalFields: new Set<string>(),
+        extensions: new Set<string>(),
+        taxonomies: new Set<string>(),
+      };
+
+      (handler as any).traverseSchemaForDependencies(schema, dependencies);
+
+      expect(dependencies.extensions.has('rich_text_editor')).to.be.true;
+      expect(dependencies.extensions.has('color_picker_ext')).to.be.true;
+      expect(dependencies.extensions.size).to.equal(2);
+    });
+
+    it('should extract taxonomy dependencies from schema', () => {
+      const schema = [
+        {
+          uid: 'categories',
+          data_type: 'taxonomy',
+          taxonomies: [{ taxonomy_uid: 'product_categories' }, { taxonomy_uid: 'product_tags' }],
+        },
+      ];
+
+      const dependencies = {
+        globalFields: new Set<string>(),
+        extensions: new Set<string>(),
+        taxonomies: new Set<string>(),
+      };
+
+      (handler as any).traverseSchemaForDependencies(schema, dependencies);
+
+      expect(dependencies.taxonomies.has('product_categories')).to.be.true;
+      expect(dependencies.taxonomies.has('product_tags')).to.be.true;
+      expect(dependencies.taxonomies.size).to.equal(2);
+    });
+
+    it('should handle group fields with nested dependencies', () => {
+      const schema = [
+        {
+          uid: 'content_section',
+          data_type: 'group',
+          schema: [
+            {
+              uid: 'seo',
+              data_type: 'global_field',
+              reference_to: 'nested_seo',
+            },
+            {
+              uid: 'rich_content',
+              data_type: 'text',
+              extension_uid: 'nested_editor',
+            },
+          ],
+        },
+      ];
+
+      const dependencies = {
+        globalFields: new Set<string>(),
+        extensions: new Set<string>(),
+        taxonomies: new Set<string>(),
+      };
+
+      (handler as any).traverseSchemaForDependencies(schema, dependencies);
+
+      expect(dependencies.globalFields.has('nested_seo')).to.be.true;
+      expect(dependencies.extensions.has('nested_editor')).to.be.true;
+    });
+
+    it('should handle block fields with nested dependencies', () => {
+      const schema = [
+        {
+          uid: 'content_blocks',
+          data_type: 'blocks',
+          blocks: {
+            hero_block: {
+              schema: [
+                {
+                  uid: 'seo',
+                  data_type: 'global_field',
+                  reference_to: 'hero_seo',
+                },
+              ],
+            },
+            content_block: {
+              schema: [
+                {
+                  uid: 'editor',
+                  data_type: 'text',
+                  extension_uid: 'content_editor',
+                },
+                {
+                  uid: 'tags',
+                  data_type: 'taxonomy',
+                  taxonomies: [{ taxonomy_uid: 'content_tags' }],
+                },
+              ],
+            },
+          },
+        },
+      ];
+
+      const dependencies = {
+        globalFields: new Set<string>(),
+        extensions: new Set<string>(),
+        taxonomies: new Set<string>(),
+      };
+
+      (handler as any).traverseSchemaForDependencies(schema, dependencies);
+
+      expect(dependencies.globalFields.has('hero_seo')).to.be.true;
+      expect(dependencies.extensions.has('content_editor')).to.be.true;
+      expect(dependencies.taxonomies.has('content_tags')).to.be.true;
+    });
+
+    it('should handle complex nested structures', () => {
+      const schema = [
+        {
+          uid: 'sections',
+          data_type: 'group',
+          schema: [
+            {
+              uid: 'content_blocks',
+              data_type: 'blocks',
+              blocks: {
+                nested_block: {
+                  schema: [
+                    {
+                      uid: 'nested_group',
+                      data_type: 'group',
+                      schema: [
+                        {
+                          uid: 'deep_global',
+                          data_type: 'global_field',
+                          reference_to: 'deep_nested_global',
+                        },
+                      ],
+                    },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      ];
+
+      const dependencies = {
+        globalFields: new Set<string>(),
+        extensions: new Set<string>(),
+        taxonomies: new Set<string>(),
+      };
+
+      (handler as any).traverseSchemaForDependencies(schema, dependencies);
+
+      expect(dependencies.globalFields.has('deep_nested_global')).to.be.true;
+    });
+
+    it('should ignore fields without dependency information', () => {
+      const schema = [
+        {
+          uid: 'title',
+          data_type: 'text',
+        },
+        {
+          uid: 'description',
+          data_type: 'text',
+        },
+      ];
+
+      const dependencies = {
+        globalFields: new Set<string>(),
+        extensions: new Set<string>(),
+        taxonomies: new Set<string>(),
+      };
+
+      (handler as any).traverseSchemaForDependencies(schema, dependencies);
+
+      expect(dependencies.globalFields.size).to.equal(0);
+      expect(dependencies.extensions.size).to.equal(0);
+      expect(dependencies.taxonomies.size).to.equal(0);
+    });
+
+    it('should handle taxonomies without taxonomy_uid gracefully', () => {
+      const schema = [
+        {
+          uid: 'categories',
+          data_type: 'taxonomy',
+          taxonomies: [
+            { name: 'Category 1' }, // Missing taxonomy_uid
+            { taxonomy_uid: 'valid_taxonomy' },
+          ],
+        },
+      ];
+
+      const dependencies = {
+        globalFields: new Set<string>(),
+        extensions: new Set<string>(),
+        taxonomies: new Set<string>(),
+      };
+
+      (handler as any).traverseSchemaForDependencies(schema, dependencies);
+
+      expect(dependencies.taxonomies.has('valid_taxonomy')).to.be.true;
+      expect(dependencies.taxonomies.size).to.equal(1);
+    });
+
+    it('should handle mixed dependency types in single schema', () => {
+      const schema = [
+        {
+          uid: 'seo',
+          data_type: 'global_field',
+          reference_to: 'seo_global',
+        },
+        {
+          uid: 'rich_text',
+          data_type: 'text',
+          extension_uid: 'editor_ext',
+        },
+        {
+          uid: 'categories',
+          data_type: 'taxonomy',
+          taxonomies: [{ taxonomy_uid: 'categories_tax' }],
+        },
+      ];
+
+      const dependencies = {
+        globalFields: new Set<string>(),
+        extensions: new Set<string>(),
+        taxonomies: new Set<string>(),
+      };
+
+      (handler as any).traverseSchemaForDependencies(schema, dependencies);
+
+      expect(dependencies.globalFields.has('seo_global')).to.be.true;
+      expect(dependencies.extensions.has('editor_ext')).to.be.true;
+      expect(dependencies.taxonomies.has('categories_tax')).to.be.true;
+      expect(dependencies.globalFields.size).to.equal(1);
+      expect(dependencies.extensions.size).to.equal(1);
+      expect(dependencies.taxonomies.size).to.equal(1);
+    });
+
+    it('should handle empty schema arrays', () => {
+      const schema: any[] = [];
+
+      const dependencies = {
+        globalFields: new Set<string>(),
+        extensions: new Set<string>(),
+        taxonomies: new Set<string>(),
+      };
+
+      (handler as any).traverseSchemaForDependencies(schema, dependencies);
+
+      expect(dependencies.globalFields.size).to.equal(0);
+      expect(dependencies.extensions.size).to.equal(0);
+      expect(dependencies.taxonomies.size).to.equal(0);
+    });
+
+    it('should collect nested global field inside a global field schema', () => {
+      const schema = [
+        {
+          uid: 'outer_global',
+          data_type: 'global_field',
+          reference_to: 'outer_gf_uid',
+          schema: [
+            {
+              uid: 'inner_global',
+              data_type: 'global_field',
+              reference_to: 'inner_gf_uid',
+            },
+          ],
+        },
+      ];
+
+      const dependencies = {
+        globalFields: new Set<string>(),
+        extensions: new Set<string>(),
+        taxonomies: new Set<string>(),
+      };
+
+      (handler as any).traverseSchemaForDependencies(schema, dependencies);
+
+      expect(dependencies.globalFields.has('outer_gf_uid')).to.be.true;
+      expect(dependencies.globalFields.has('inner_gf_uid')).to.be.true;
+      expect(dependencies.globalFields.size).to.equal(2);
+    });
+
+    it('should collect extension nested inside a global field schema', () => {
+      const schema = [
+        {
+          uid: 'seo_block',
+          data_type: 'global_field',
+          reference_to: 'seo_gf',
+          schema: [
+            {
+              uid: 'rich_editor',
+              data_type: 'text',
+              extension_uid: 'nested_editor_ext',
+            },
+          ],
+        },
+      ];
+
+      const dependencies = {
+        globalFields: new Set<string>(),
+        extensions: new Set<string>(),
+        taxonomies: new Set<string>(),
+      };
+
+      (handler as any).traverseSchemaForDependencies(schema, dependencies);
+
+      expect(dependencies.globalFields.has('seo_gf')).to.be.true;
+      expect(dependencies.extensions.has('nested_editor_ext')).to.be.true;
+    });
+
+    it('should collect taxonomy nested inside a global field schema', () => {
+      const schema = [
+        {
+          uid: 'tags_block',
+          data_type: 'global_field',
+          reference_to: 'tags_gf',
+          schema: [
+            {
+              uid: 'categories',
+              data_type: 'taxonomy',
+              taxonomies: [{ taxonomy_uid: 'nested_taxonomy_uid' }],
+            },
+          ],
+        },
+      ];
+
+      const dependencies = {
+        globalFields: new Set<string>(),
+        extensions: new Set<string>(),
+        taxonomies: new Set<string>(),
+      };
+
+      (handler as any).traverseSchemaForDependencies(schema, dependencies);
+
+      expect(dependencies.globalFields.has('tags_gf')).to.be.true;
+      expect(dependencies.taxonomies.has('nested_taxonomy_uid')).to.be.true;
+    });
+
+    it('should collect deeply nested global field inside a global field inside a group', () => {
+      const schema = [
+        {
+          uid: 'content_section',
+          data_type: 'group',
+          schema: [
+            {
+              uid: 'outer_gf',
+              data_type: 'global_field',
+              reference_to: 'outer_gf_uid',
+              schema: [
+                {
+                  uid: 'inner_gf',
+                  data_type: 'global_field',
+                  reference_to: 'inner_gf_uid',
+                  schema: [
+                    {
+                      uid: 'deepest_gf',
+                      data_type: 'global_field',
+                      reference_to: 'deepest_gf_uid',
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ];
+
+      const dependencies = {
+        globalFields: new Set<string>(),
+        extensions: new Set<string>(),
+        taxonomies: new Set<string>(),
+      };
+
+      (handler as any).traverseSchemaForDependencies(schema, dependencies);
+
+      expect(dependencies.globalFields.has('outer_gf_uid')).to.be.true;
+      expect(dependencies.globalFields.has('inner_gf_uid')).to.be.true;
+      expect(dependencies.globalFields.has('deepest_gf_uid')).to.be.true;
+      expect(dependencies.globalFields.size).to.equal(3);
+    });
+  });
+
+  describe('extractDependencies — explicit schemas parameter', () => {
+    let extensionQueryStub: sinon.SinonStub;
+
+    beforeEach(() => {
+      extensionQueryStub = sinon.stub().returns({ find: sinon.stub().resolves({ items: [] }) });
+      mockStackAPIClient.extension = sinon.stub().returns({ query: extensionQueryStub });
+      handler = new ContentTypeDependenciesHandler(mockStackAPIClient, mockConfig);
+    });
+
+    it('should collect global field deps from provided CT schemas', async () => {
+      const schemas = [
+        { uid: 'page', schema: [{ uid: 'seo', data_type: 'global_field', reference_to: 'seo_gf' }] },
+      ];
+
+      const deps = await handler.extractDependencies(schemas);
+
+      expect(deps.globalFields.has('seo_gf')).to.be.true;
+    });
+
+    it('should collect global field deps from provided GF schemas (transitive case)', async () => {
+      // GF A's schema contains a reference to GF B — simulates what happens when
+      // the caller passes the combined [CT doc, GF A doc] list.
+      const schemas = [
+        { uid: 'page', schema: [{ uid: 'gf_a_field', data_type: 'global_field', reference_to: 'gf_a' }] },
+        {
+          uid: 'gf_a',
+          schema: [{ uid: 'gf_b_field', data_type: 'global_field', reference_to: 'gf_b' }],
+        },
+      ];
+
+      const deps = await handler.extractDependencies(schemas);
+
+      expect(deps.globalFields.has('gf_a')).to.be.true;
+      expect(deps.globalFields.has('gf_b')).to.be.true;
+    });
+
+    it('should collect extension deps from GF schemas', async () => {
+      // Return the extension as a regular extension from the API so it ends up in deps.extensions.
+      extensionQueryStub = sinon.stub().returns({
+        find: sinon.stub().resolves({ items: [{ uid: 'color_picker_ext' }] }),
+      });
+      mockStackAPIClient.extension = sinon.stub().returns({ query: extensionQueryStub });
+      handler = new ContentTypeDependenciesHandler(mockStackAPIClient, mockConfig);
+
+      const schemas = [
+        { uid: 'page', schema: [{ uid: 'gf_a_field', data_type: 'global_field', reference_to: 'gf_a' }] },
+        {
+          uid: 'gf_a',
+          schema: [{ uid: 'bg_color', data_type: 'text', extension_uid: 'color_picker_ext' }],
+        },
+      ];
+
+      const deps = await handler.extractDependencies(schemas);
+
+      expect(deps.globalFields.has('gf_a')).to.be.true;
+      expect(deps.extensions.has('color_picker_ext')).to.be.true;
+    });
+
+    it('should collect taxonomy deps from GF schemas', async () => {
+      const schemas = [
+        { uid: 'page', schema: [{ uid: 'gf_a_field', data_type: 'global_field', reference_to: 'gf_a' }] },
+        {
+          uid: 'gf_a',
+          schema: [
+            {
+              uid: 'tags',
+              data_type: 'taxonomy',
+              taxonomies: [{ taxonomy_uid: 'product_taxonomy' }],
+            },
+          ],
+        },
+      ];
+
+      const deps = await handler.extractDependencies(schemas);
+
+      expect(deps.taxonomies.has('product_taxonomy')).to.be.true;
+    });
+
+    it('should return empty sets when schemas array is empty', async () => {
+      const deps = await handler.extractDependencies([]);
+
+      expect(deps.globalFields.size).to.equal(0);
+      expect(deps.extensions.size).to.equal(0);
+      expect(deps.taxonomies.size).to.equal(0);
+      expect(deps.marketplaceApps.size).to.equal(0);
+    });
+
+    it('should skip docs that have no schema array', async () => {
+      const schemas = [
+        { uid: 'page' }, // no schema property
+        { uid: 'blog', schema: [{ uid: 'seo', data_type: 'global_field', reference_to: 'seo_gf' }] },
+      ];
+
+      const deps = await handler.extractDependencies(schemas);
+
+      expect(deps.globalFields.has('seo_gf')).to.be.true;
+      expect(deps.globalFields.size).to.equal(1);
+    });
+  });
+});
diff --git a/packages/contentstack-query-export/test/unit/module-exporter.test.ts b/packages/contentstack-query-export/test/unit/module-exporter.test.ts
new file mode 100644
index 000000000..3b7142c0a
--- /dev/null
+++ b/packages/contentstack-query-export/test/unit/module-exporter.test.ts
@@ -0,0 +1,207 @@
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { ModuleExporter } from '../../src/core/module-exporter';
+import * as logger from '../../src/utils/logger';
+import ExportCommand from '@contentstack/cli-cm-export';
+
+describe('ModuleExporter', () => {
+  let sandbox: sinon.SinonSandbox;
+  let moduleExporter: ModuleExporter;
+  let mockStackAPIClient: any;
+  let mockConfig: any;
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox();
+
+    // Mock stack API client
+    mockStackAPIClient = {
+      contentType: sandbox.stub(),
+      entry: sandbox.stub(),
+      asset: sandbox.stub(),
+    };
+
+    // Mock export configuration
+    mockConfig = {
+      exportDir: './test-export',
+      stackApiKey: 'test-stack-api-key',
+      managementToken: 'test-management-token',
+      branchName: 'main',
+      securedAssets: false,
+      externalConfigPath: './config/export-config.json',
+    };
+
+    // Stub logger to prevent console output during tests
+    sandbox.stub(logger, 'log');
+
+    moduleExporter = new ModuleExporter(mockConfig);
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe('constructor', () => {
+    it('should initialize ModuleExporter with correct configuration', () => {
+      expect(moduleExporter).to.be.an('object');
+      expect((moduleExporter as any).exportQueryConfig).to.equal(mockConfig);
+      expect((moduleExporter as any).exportedModules).to.be.an('array').that.is.empty;
+    });
+  });
+
+  describe('buildExportCommand', () => {
+    it('should build basic export command with required parameters', () => {
+      const cmd = (moduleExporter as any).buildExportCommand('entries', {});
+
+      expect(cmd).to.include('-k', 'test-stack-api-key');
+      expect(cmd).to.include('-d', './test-export');
+      expect(cmd).to.include('--module', 'entries');
+      expect(cmd).to.include('-a', 'test-management-token');
+      expect(cmd).to.include('-y');
+    });
+
+    it('should include branch when specified in config', () => {
+      const cmd = (moduleExporter as any).buildExportCommand('content-types', {});
+
+      expect(cmd).to.include('--branch', 'main');
+    });
+
+    it('should include branch from options over config', () => {
+      const cmd = (moduleExporter as any).buildExportCommand('content-types', {
+        branch: 'development',
+      });
+
+      expect(cmd).to.include('--branch', 'development');
+    });
+
+    it('should include query when provided in options', () => {
+      const query = {
+        modules: {
+          entries: { content_type_uid: 'page' },
+        },
+      };
+
+      const cmd = (moduleExporter as any).buildExportCommand('entries', { query });
+
+      expect(cmd).to.include('--query', JSON.stringify(query));
+    });
+
+    it('should include secured assets flag when enabled in config', () => {
+      mockConfig.securedAssets = true;
+      moduleExporter = new ModuleExporter(mockConfig);
+
+      const cmd = (moduleExporter as any).buildExportCommand('assets', {});
+
+      expect(cmd).to.include('--secured-assets');
+    });
+
+    it('should include secured assets from options over config', () => {
+      const cmd = (moduleExporter as any).buildExportCommand('assets', {
+        securedAssets: true,
+      });
+
+      expect(cmd).to.include('--secured-assets');
+    });
+
+    it('should use alias over management token when provided', () => {
+      const cmd = (moduleExporter as any).buildExportCommand('environments', {
+        alias: 'production-stack',
+      });
+
+      expect(cmd).to.include('-a', 'production-stack');
+      expect(cmd).to.not.include('test-management-token');
+    });
+
+    it('should include external config path when specified', () => {
+      const cmd = (moduleExporter as any).buildExportCommand('locales', {});
+
+      expect(cmd).to.include('--config', './config/export-config.json');
+    });
+
+    it('should use custom config path from options', () => {
+      const cmd = (moduleExporter as any).buildExportCommand('locales', {
+        configPath: './custom-config.json',
+      });
+
+      expect(cmd).to.include('--config', './custom-config.json');
+    });
+
+    it('should use custom directory from options', () => {
+      const cmd = (moduleExporter as any).buildExportCommand('entries', {
+        directory: './custom-export',
+      });
+
+      expect(cmd).to.include('-d', './custom-export');
+    });
+
+    it('should handle missing optional parameters', () => {
+      mockConfig.branchName = undefined;
+      mockConfig.externalConfigPath = undefined;
+      mockConfig.managementToken = undefined;
+      moduleExporter = new ModuleExporter(mockConfig);
+
+      const cmd = (moduleExporter as any).buildExportCommand('entries', {});
+
+      expect(cmd).to.include('-k', 'test-stack-api-key');
+      expect(cmd).to.include('-d', './test-export');
+      expect(cmd).to.not.include('--branch');
+      expect(cmd).to.not.include('--config');
+      expect(cmd).to.not.include('-a');
+    });
+  });
+
+  describe('exportModule', () => {
+    let runStub: sinon.SinonStub;
+
+    beforeEach(() => {
+      // Stub ExportCommand.run to prevent actual exports
+      runStub = sandbox.stub(ExportCommand, 'run').resolves();
+    });
+
+    it('should export a module with correct parameters', async () => {
+      await moduleExporter.exportModule('entries');
+
+      expect(runStub.calledOnce).to.be.true;
+      const args = runStub.firstCall.args[0];
+      expect(args).to.include('--module', 'entries');
+    });
+
+    it('should handle errors during export', async () => {
+      const error = new Error('Export failed');
+      runStub.rejects(error);
+
+      try {
+        await moduleExporter.exportModule('entries');
+        expect.fail('Should have thrown an error');
+      } catch (err) {
+        expect(err).to.equal(error);
+      }
+    });
+
+    it('should apply delay before exporting', async () => {
+      const clock = sandbox.useFakeTimers();
+      const exportPromise = moduleExporter.exportModule('entries');
+
+      expect(runStub.called).to.be.false;
+      clock.tick(2000); // Default delay
+      await exportPromise;
+
+      expect(runStub.calledOnce).to.be.true;
+    });
+
+    it('should use custom delay from config', async () => {
+      mockConfig.exportDelayMs = 5000;
+      moduleExporter = new ModuleExporter(mockConfig);
+
+      const clock = sandbox.useFakeTimers();
+      const exportPromise = moduleExporter.exportModule('entries');
+
+      clock.tick(2000); // Not enough time
+      expect(runStub.called).to.be.false;
+
+      clock.tick(3000); // Complete the delay
+      await exportPromise;
+
+      expect(runStub.calledOnce).to.be.true;
+    });
+  });
+});
diff --git a/packages/contentstack-query-export/test/unit/query-executor.test.ts b/packages/contentstack-query-export/test/unit/query-executor.test.ts
new file mode 100644
index 000000000..a3cfd4bc6
--- /dev/null
+++ b/packages/contentstack-query-export/test/unit/query-executor.test.ts
@@ -0,0 +1,628 @@
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { QueryExporter } from '../../src/core/query-executor';
+import { QueryParser } from '../../src/utils/query-parser';
+import { ModuleExporter } from '../../src/core/module-exporter';
+import * as logger from '../../src/utils/logger';
+import {
+  ReferencedContentTypesHandler,
+  ContentTypeDependenciesHandler,
+  AssetReferenceHandler,
+  fsUtil,
+} from '../../src/utils';
+import * as contentTypeUtils from '@contentstack/cli-utilities/lib/content-type-utils';
+
+describe('QueryExporter', () => {
+  let sandbox: sinon.SinonSandbox;
+  let queryExporter: QueryExporter;
+  let mockManagementClient: any;
+  let mockConfig: any;
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox();
+
+    // Mock management client
+    mockManagementClient = {
+      stack: sandbox.stub().returns({}),
+    };
+
+    // Mock export configuration
+    mockConfig = {
+      exportDir: './test-export',
+      stackApiKey: 'test-stack-api-key',
+      managementToken: 'test-management-token',
+      query: '{"modules":{"entries":{"content_type_uid":"test_page"}}}',
+      modules: {
+        general: ['environments', 'locales'],
+        queryable: ['entries', 'assets', 'content-types'],
+      },
+      branchName: 'main',
+      securedAssets: false,
+      externalConfigPath: './config/export-config.json',
+      maxCTReferenceDepth: 20,
+    };
+
+    // Stub logger to prevent console output during tests
+    sandbox.stub(logger, 'log');
+
+    queryExporter = new QueryExporter(mockManagementClient, mockConfig);
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe('constructor', () => {
+    it('should initialize QueryExporter with correct configuration', () => {
+      expect(queryExporter).to.be.an('object');
+      expect((queryExporter as any).exportQueryConfig).to.equal(mockConfig);
+      expect((queryExporter as any).queryParser).to.be.an.instanceof(QueryParser);
+      expect((queryExporter as any).moduleExporter).to.be.an.instanceof(ModuleExporter);
+    });
+
+    it('should create QueryParser instance with correct config', () => {
+      const queryParser = (queryExporter as any).queryParser;
+      expect(queryParser).to.be.an.instanceof(QueryParser);
+    });
+
+    it('should create ModuleExporter instance', () => {
+      const moduleExporter = (queryExporter as any).moduleExporter;
+      expect(moduleExporter).to.be.an.instanceof(ModuleExporter);
+    });
+  });
+
+  describe('execute', () => {
+    let queryParserStub: sinon.SinonStub;
+    let exportGeneralModulesStub: sinon.SinonStub;
+    let exportQueriedModuleStub: sinon.SinonStub;
+    let expandSchemaClosureStub: sinon.SinonStub;
+    let exportContentModulesStub: sinon.SinonStub;
+
+    beforeEach(() => {
+      queryParserStub = sandbox.stub((queryExporter as any).queryParser, 'parse').resolves({
+        modules: { entries: { content_type_uid: 'test_page' } },
+      });
+      exportGeneralModulesStub = sandbox.stub(queryExporter as any, 'exportGeneralModules').resolves();
+      exportQueriedModuleStub = sandbox.stub(queryExporter as any, 'exportQueriedModule').resolves();
+      expandSchemaClosureStub = sandbox.stub(queryExporter as any, 'expandSchemaClosure').resolves();
+      exportContentModulesStub = sandbox.stub(queryExporter as any, 'exportContentModules').resolves();
+    });
+
+    it('should execute the complete export workflow', async () => {
+      await queryExporter.execute();
+
+      expect(queryParserStub.calledOnce).to.be.true;
+      expect(exportGeneralModulesStub.calledOnce).to.be.true;
+      expect(exportQueriedModuleStub.calledOnce).to.be.true;
+      expect(expandSchemaClosureStub.calledOnce).to.be.true;
+      expect(exportContentModulesStub.calledOnce).to.be.true;
+    });
+
+    it('should call methods in correct order', async () => {
+      await queryExporter.execute();
+
+      sinon.assert.callOrder(
+        queryParserStub,
+        exportGeneralModulesStub,
+        exportQueriedModuleStub,
+        expandSchemaClosureStub,
+        exportContentModulesStub,
+      );
+    });
+
+    it('should pass parsed query to exportQueriedModule', async () => {
+      const mockParsedQuery = { modules: { entries: { content_type_uid: 'test_page' } } };
+      queryParserStub.resolves(mockParsedQuery);
+
+      await queryExporter.execute();
+
+      expect(exportQueriedModuleStub.calledWith(mockParsedQuery)).to.be.true;
+    });
+
+    it('should handle query parsing errors', async () => {
+      const queryError = new Error('Invalid query format');
+      queryParserStub.rejects(queryError);
+
+      try {
+        await queryExporter.execute();
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.equal('Invalid query format');
+      }
+
+      expect(exportGeneralModulesStub.called).to.be.false;
+    });
+
+    it('should handle export errors and propagate them', async () => {
+      const exportError = new Error('Export failed');
+      exportGeneralModulesStub.rejects(exportError);
+
+      try {
+        await queryExporter.execute();
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.equal('Export failed');
+      }
+    });
+  });
+
+  describe('exportGeneralModules', () => {
+    let moduleExporterStub: sinon.SinonStub;
+
+    beforeEach(() => {
+      moduleExporterStub = sandbox.stub((queryExporter as any).moduleExporter, 'exportModule').resolves();
+    });
+
+    it('should export all general modules', async () => {
+      await (queryExporter as any).exportGeneralModules();
+
+      expect(moduleExporterStub.callCount).to.equal(2);
+      expect(moduleExporterStub.calledWith('environments')).to.be.true;
+      expect(moduleExporterStub.calledWith('locales')).to.be.true;
+    });
+
+    it('should handle empty general modules array', async () => {
+      mockConfig.modules.general = [];
+      queryExporter = new QueryExporter(mockManagementClient, mockConfig);
+      moduleExporterStub = sandbox.stub((queryExporter as any).moduleExporter, 'exportModule').resolves();
+
+      await (queryExporter as any).exportGeneralModules();
+
+      expect(moduleExporterStub.called).to.be.false;
+    });
+
+    it('should handle module export errors', async () => {
+      const moduleError = new Error('Module export failed');
+      moduleExporterStub.rejects(moduleError);
+
+      try {
+        await (queryExporter as any).exportGeneralModules();
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.equal('Module export failed');
+      }
+    });
+  });
+
+  describe('exportQueriedModule', () => {
+    let moduleExporterStub: sinon.SinonStub;
+
+    beforeEach(() => {
+      moduleExporterStub = sandbox.stub((queryExporter as any).moduleExporter, 'exportModule').resolves();
+    });
+
+    it('should export queryable modules with query', async () => {
+      const parsedQuery = {
+        modules: {
+          entries: { content_type_uid: 'test_page' },
+          assets: { tags: 'featured' },
+        },
+      };
+
+      await (queryExporter as any).exportQueriedModule(parsedQuery);
+
+      expect(moduleExporterStub.callCount).to.equal(2);
+      expect(moduleExporterStub.calledWith('entries', { query: parsedQuery })).to.be.true;
+      expect(moduleExporterStub.calledWith('assets', { query: parsedQuery })).to.be.true;
+    });
+
+    it('should skip non-queryable modules', async () => {
+      mockConfig.modules.queryable = ['entries']; // Remove assets from queryable
+      queryExporter = new QueryExporter(mockManagementClient, mockConfig);
+      moduleExporterStub = sandbox.stub((queryExporter as any).moduleExporter, 'exportModule').resolves();
+
+      const parsedQuery = {
+        modules: {
+          entries: { content_type_uid: 'test_page' },
+          environments: { name: 'production' }, // Not queryable
+        },
+      };
+
+      await (queryExporter as any).exportQueriedModule(parsedQuery);
+
+      expect(moduleExporterStub.callCount).to.equal(1);
+      expect(moduleExporterStub.calledWith('entries', { query: parsedQuery })).to.be.true;
+    });
+
+    it('should handle empty modules in query', async () => {
+      const parsedQuery = { modules: {} };
+
+      await (queryExporter as any).exportQueriedModule(parsedQuery);
+
+      expect(moduleExporterStub.called).to.be.false;
+    });
+  });
+
+  describe('expandSchemaClosure', () => {
+    let moduleExporterStub: sinon.SinonStub;
+    let readContentTypeSchemasStub: sinon.SinonStub;
+    let referencedHandlerStub: any;
+    let dependenciesHandlerStub: any;
+
+    const mockCTs = [{ uid: 'page', title: 'Page', schema: [] as any[] }];
+    const emptyDeps = {
+      globalFields: new Set<string>(),
+      extensions: new Set<string>(),
+      taxonomies: new Set<string>(),
+      marketplaceApps: new Set<string>(),
+    };
+
+    beforeEach(() => {
+      moduleExporterStub = sandbox.stub((queryExporter as any).moduleExporter, 'exportModule').resolves();
+
+      // Default: CT path returns mockCTs, GF path returns empty.
+      readContentTypeSchemasStub = sandbox
+        .stub(contentTypeUtils, 'readContentTypeSchemas')
+        .callsFake((dirPath: string) => (dirPath.includes('global_fields') ? [] : mockCTs));
+
+      referencedHandlerStub = { extractReferencedContentTypes: sandbox.stub().resolves([]) };
+      sandbox
+        .stub(ReferencedContentTypesHandler.prototype, 'extractReferencedContentTypes')
+        .callsFake(referencedHandlerStub.extractReferencedContentTypes);
+
+      dependenciesHandlerStub = { extractDependencies: sandbox.stub().resolves(emptyDeps) };
+      sandbox
+        .stub(ContentTypeDependenciesHandler.prototype, 'extractDependencies')
+        .callsFake(dependenciesHandlerStub.extractDependencies);
+    });
+
+    it('should export personalize exactly once when no new items are found', async () => {
+      await (queryExporter as any).expandSchemaClosure();
+
+      const personalizeCalls = moduleExporterStub.getCalls().filter((c) => c.args[0] === 'personalize');
+      expect(personalizeCalls).to.have.lengthOf(1);
+      // No CT or GF export should have happened
+      expect(moduleExporterStub.getCalls().filter((c) => c.args[0] === 'content-types')).to.have.lengthOf(0);
+      expect(moduleExporterStub.getCalls().filter((c) => c.args[0] === 'global-fields')).to.have.lengthOf(0);
+    });
+
+    it('should pass combined CT and GF schemas to extractReferencedContentTypes', async () => {
+      const mockGFs = [{ uid: 'seo_gf', schema: [] as any[] }];
+      readContentTypeSchemasStub.callsFake((dirPath: string) =>
+        dirPath.includes('global_fields') ? mockGFs : mockCTs,
+      );
+
+      await (queryExporter as any).expandSchemaClosure();
+
+      const callArgs = referencedHandlerStub.extractReferencedContentTypes.getCall(0).args[0];
+      expect(callArgs).to.deep.include({ uid: 'page', title: 'Page', schema: [] as any[] });
+      expect(callArgs).to.deep.include({ uid: 'seo_gf', schema: [] as any[] });
+    });
+
+    it('should pass combined CT and GF schemas to extractDependencies', async () => {
+      const mockGFs = [{ uid: 'seo_gf', schema: [] as any[] }];
+      readContentTypeSchemasStub.callsFake((dirPath: string) =>
+        dirPath.includes('global_fields') ? mockGFs : mockCTs,
+      );
+
+      await (queryExporter as any).expandSchemaClosure();
+
+      const callArgs = dependenciesHandlerStub.extractDependencies.getCall(0).args[0];
+      expect(callArgs).to.deep.include({ uid: 'page', title: 'Page', schema: [] as any[] });
+      expect(callArgs).to.deep.include({ uid: 'seo_gf', schema: [] as any[] });
+    });
+
+    it('should export new referenced content types found in CT schemas', async () => {
+      referencedHandlerStub.extractReferencedContentTypes
+        .onFirstCall()
+        .resolves(['new_ct'])
+        .resolves([]);
+
+      await (queryExporter as any).expandSchemaClosure();
+
+      const ctCall = moduleExporterStub.getCalls().find((c) => c.args[0] === 'content-types');
+      expect(ctCall).to.exist;
+      expect(ctCall!.args[1].query.modules['content-types'].uid.$in).to.deep.equal(['new_ct']);
+    });
+
+    it('should export new global fields discovered from CT schemas', async () => {
+      dependenciesHandlerStub.extractDependencies
+        .onFirstCall()
+        .resolves({ globalFields: new Set(['gf_a']), extensions: new Set(), taxonomies: new Set(), marketplaceApps: new Set() })
+        .resolves(emptyDeps);
+
+      await (queryExporter as any).expandSchemaClosure();
+
+      const gfCall = moduleExporterStub.getCalls().find((c) => c.args[0] === 'global-fields');
+      expect(gfCall).to.exist;
+      expect(gfCall!.args[1].query.modules['global-fields'].uid.$in).to.deep.equal(['gf_a']);
+    });
+
+    it('should iterate to find CT references inside global field schemas', async () => {
+      // Iter 1: GF A is newly discovered from CT deps. GF A is not yet on disk.
+      // Iter 2: GF A is now on disk; its schema exposes a reference to CT B.
+      const gfADoc = [{ uid: 'gf_a', schema: [] as any[] }];
+
+      readContentTypeSchemasStub.callsFake((dirPath: string) => {
+        if (dirPath.includes('global_fields')) {
+          return dependenciesHandlerStub.extractDependencies.callCount > 1 ? gfADoc : [];
+        }
+        return mockCTs;
+      });
+
+      dependenciesHandlerStub.extractDependencies
+        .onFirstCall()
+        .resolves({ globalFields: new Set(['gf_a']), extensions: new Set(), taxonomies: new Set(), marketplaceApps: new Set() })
+        .resolves(emptyDeps);
+
+      referencedHandlerStub.extractReferencedContentTypes
+        .onFirstCall().resolves([])       // iter 1: only CTs on disk, no CT refs
+        .onSecondCall().resolves(['ct_b']) // iter 2: GF A adds a CT ref to ct_b
+        .resolves([]);
+
+      await (queryExporter as any).expandSchemaClosure();
+
+      const ctCall = moduleExporterStub.getCalls().find((c) => c.args[0] === 'content-types');
+      expect(ctCall).to.exist;
+      expect(ctCall!.args[1].query.modules['content-types'].uid.$in).to.include('ct_b');
+
+      const gfCall = moduleExporterStub.getCalls().find((c) => c.args[0] === 'global-fields');
+      expect(gfCall).to.exist;
+      expect(gfCall!.args[1].query.modules['global-fields'].uid.$in).to.include('gf_a');
+    });
+
+    it('should not re-export already exported global fields across iterations', async () => {
+      // gf_a is returned by extractDependencies on every call, but should only be exported once.
+      dependenciesHandlerStub.extractDependencies.resolves({
+        globalFields: new Set(['gf_a']),
+        extensions: new Set(),
+        taxonomies: new Set(),
+        marketplaceApps: new Set(),
+      });
+
+      // Trigger a second iteration via a new CT reference so we can verify gf_a is not re-exported.
+      referencedHandlerStub.extractReferencedContentTypes
+        .onFirstCall().resolves(['new_ct'])
+        .resolves([]);
+
+      await (queryExporter as any).expandSchemaClosure();
+
+      const gfCalls = moduleExporterStub.getCalls().filter((c) => c.args[0] === 'global-fields');
+      expect(gfCalls).to.have.lengthOf(1);
+    });
+
+    it('should not re-export already exported content types across iterations', async () => {
+      // new_ct returned on first AND second call — should only be exported once.
+      referencedHandlerStub.extractReferencedContentTypes
+        .onFirstCall().resolves(['new_ct'])
+        .onSecondCall().resolves(['new_ct']) // already exported — should be filtered
+        .resolves([]);
+
+      // Trigger a second iteration via a new GF dep.
+      dependenciesHandlerStub.extractDependencies
+        .onFirstCall().resolves({ globalFields: new Set(['gf_a']), extensions: new Set(), taxonomies: new Set(), marketplaceApps: new Set() })
+        .resolves(emptyDeps);
+
+      await (queryExporter as any).expandSchemaClosure();
+
+      const ctCalls = moduleExporterStub.getCalls().filter((c) => c.args[0] === 'content-types');
+      expect(ctCalls).to.have.lengthOf(1);
+    });
+
+    it('should export extensions, taxonomies, and marketplace apps as leaf deps', async () => {
+      dependenciesHandlerStub.extractDependencies.resolves({
+        globalFields: new Set(),
+        extensions: new Set(['ext_1']),
+        taxonomies: new Set(['tax_1']),
+        marketplaceApps: new Set(['mp_app_1']),
+      });
+
+      await (queryExporter as any).expandSchemaClosure();
+
+      expect(moduleExporterStub.getCalls().some((c) => c.args[0] === 'extensions')).to.be.true;
+      expect(moduleExporterStub.getCalls().some((c) => c.args[0] === 'taxonomies')).to.be.true;
+      expect(moduleExporterStub.getCalls().some((c) => c.args[0] === 'marketplace-apps')).to.be.true;
+    });
+
+    it('should skip CT reference extraction when skipReferences is true', async () => {
+      mockConfig.skipReferences = true;
+      const localExporter = new QueryExporter(mockManagementClient, mockConfig);
+      const localModuleStub = sandbox.stub((localExporter as any).moduleExporter, 'exportModule').resolves();
+
+      await (localExporter as any).expandSchemaClosure();
+
+      expect(referencedHandlerStub.extractReferencedContentTypes.called).to.be.false;
+      expect(localModuleStub.getCalls().filter((c) => c.args[0] === 'content-types')).to.have.lengthOf(0);
+    });
+
+    it('should skip dependency extraction when skipDependencies is true', async () => {
+      mockConfig.skipDependencies = true;
+      const localExporter = new QueryExporter(mockManagementClient, mockConfig);
+      const localModuleStub = sandbox.stub((localExporter as any).moduleExporter, 'exportModule').resolves();
+
+      await (localExporter as any).expandSchemaClosure();
+
+      expect(dependenciesHandlerStub.extractDependencies.called).to.be.false;
+      expect(localModuleStub.getCalls().filter((c) => c.args[0] === 'global-fields')).to.have.lengthOf(0);
+    });
+
+    it('should stop after maxCTReferenceDepth iterations', async () => {
+      mockConfig.maxCTReferenceDepth = 2;
+      const localExporter = new QueryExporter(mockManagementClient, mockConfig);
+      sandbox.stub((localExporter as any).moduleExporter, 'exportModule').resolves();
+
+      // Always report new GFs so the loop never naturally terminates.
+      let callN = 0;
+      dependenciesHandlerStub.extractDependencies.callsFake(() => {
+        callN++;
+        return Promise.resolve({
+          globalFields: new Set([`gf_${callN}`]),
+          extensions: new Set(),
+          taxonomies: new Set(),
+          marketplaceApps: new Set(),
+        });
+      });
+
+      await (localExporter as any).expandSchemaClosure();
+
+      expect(dependenciesHandlerStub.extractDependencies.callCount).to.be.at.most(2);
+    });
+
+    it('should propagate errors from extractReferencedContentTypes', async () => {
+      referencedHandlerStub.extractReferencedContentTypes.rejects(new Error('Handler failed'));
+
+      try {
+        await (queryExporter as any).expandSchemaClosure();
+        expect.fail('Should have thrown error');
+      } catch (error: any) {
+        expect(error.message).to.equal('Handler failed');
+      }
+    });
+
+    it('should propagate errors from extractDependencies', async () => {
+      dependenciesHandlerStub.extractDependencies.rejects(new Error('Dependencies extraction failed'));
+
+      try {
+        await (queryExporter as any).expandSchemaClosure();
+        expect.fail('Should have thrown error');
+      } catch (error: any) {
+        expect(error.message).to.equal('Dependencies extraction failed');
+      }
+    });
+  });
+
+  describe('exportContentModules', () => {
+    let exportEntriesStub: sinon.SinonStub;
+    let exportReferencedAssetsStub: sinon.SinonStub;
+    let setTimeoutStub: sinon.SinonStub;
+
+    beforeEach(() => {
+      exportEntriesStub = sandbox.stub(queryExporter as any, 'exportEntries').resolves();
+      exportReferencedAssetsStub = sandbox.stub(queryExporter as any, 'exportReferencedAssets').resolves();
+
+      // Mock setTimeout to avoid actual delays in tests
+      setTimeoutStub = sandbox.stub(global, 'setTimeout').callsFake((callback) => {
+        callback();
+        return {} as any;
+      });
+    });
+
+    it('should export entries and then assets', async () => {
+      await (queryExporter as any).exportContentModules();
+
+      expect(exportEntriesStub.calledOnce).to.be.true;
+      expect(exportReferencedAssetsStub.calledOnce).to.be.true;
+      sinon.assert.callOrder(exportEntriesStub, exportReferencedAssetsStub);
+    });
+
+    it('should include delay before asset export', async () => {
+      await (queryExporter as any).exportContentModules();
+
+      expect(setTimeoutStub.calledOnce).to.be.true;
+      expect(setTimeoutStub.calledWith(sinon.match.func, 5000)).to.be.true;
+    });
+
+    it('should handle entries export errors', async () => {
+      const entriesError = new Error('Entries export failed');
+      exportEntriesStub.rejects(entriesError);
+
+      try {
+        await (queryExporter as any).exportContentModules();
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.equal('Entries export failed');
+      }
+
+      expect(exportReferencedAssetsStub.called).to.be.false;
+    });
+
+    it('should handle assets export errors', async () => {
+      const assetsError = new Error('Assets export failed');
+      exportReferencedAssetsStub.rejects(assetsError);
+
+      try {
+        await (queryExporter as any).exportContentModules();
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.equal('Assets export failed');
+      }
+    });
+  });
+
+  describe('exportEntries', () => {
+    let moduleExporterStub: sinon.SinonStub;
+
+    beforeEach(() => {
+      moduleExporterStub = sandbox.stub((queryExporter as any).moduleExporter, 'exportModule').resolves();
+    });
+
+    it('should export entries module', async () => {
+      await (queryExporter as any).exportEntries();
+
+      expect(moduleExporterStub.calledOnce).to.be.true;
+      expect(moduleExporterStub.calledWith('entries')).to.be.true;
+    });
+
+    it('should handle entries export errors', async () => {
+      const entriesError = new Error('Entries export failed');
+      moduleExporterStub.rejects(entriesError);
+
+      try {
+        await (queryExporter as any).exportEntries();
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.equal('Entries export failed');
+      }
+    });
+  });
+
+  describe('exportReferencedAssets', () => {
+    let moduleExporterStub: sinon.SinonStub;
+    let assetHandlerStub: any;
+
+    beforeEach(() => {
+      moduleExporterStub = sandbox.stub((queryExporter as any).moduleExporter, 'exportModule').resolves();
+
+      // Mock AssetReferenceHandler
+      assetHandlerStub = {
+        extractReferencedAssets: sandbox.stub().returns(['asset_1', 'asset_2', 'asset_3']),
+      };
+      sandbox
+        .stub(AssetReferenceHandler.prototype, 'extractReferencedAssets')
+        .callsFake(assetHandlerStub.extractReferencedAssets);
+    });
+
+    it('should export referenced assets when found', async () => {
+      await (queryExporter as any).exportReferencedAssets();
+
+      expect(moduleExporterStub.calledOnce).to.be.true;
+      const exportCall = moduleExporterStub.getCall(0);
+      expect(exportCall.args[0]).to.equal('assets');
+      expect(exportCall.args[1].query.modules.assets.uid.$in).to.deep.equal(['asset_1', 'asset_2', 'asset_3']);
+    });
+
+    it('should skip export when no assets found', async () => {
+      assetHandlerStub.extractReferencedAssets.returns([]);
+
+      await (queryExporter as any).exportReferencedAssets();
+
+      expect(moduleExporterStub.called).to.be.false;
+    });
+
+    it('should handle asset extraction errors', async () => {
+      const assetError = new Error('Asset extraction failed');
+      assetHandlerStub.extractReferencedAssets.throws(assetError);
+
+      try {
+        await (queryExporter as any).exportReferencedAssets();
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.equal('Asset extraction failed');
+      }
+
+      expect(moduleExporterStub.called).to.be.false;
+    });
+
+    it('should handle asset export errors', async () => {
+      const exportError = new Error('Asset export failed');
+      moduleExporterStub.rejects(exportError);
+
+      try {
+        await (queryExporter as any).exportReferencedAssets();
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.equal('Asset export failed');
+      }
+    });
+  });
+});
diff --git a/packages/contentstack-query-export/test/unit/query-parser-simple.test.ts b/packages/contentstack-query-export/test/unit/query-parser-simple.test.ts
new file mode 100644
index 000000000..297259bb5
--- /dev/null
+++ b/packages/contentstack-query-export/test/unit/query-parser-simple.test.ts
@@ -0,0 +1,156 @@
+import { expect } from 'chai';
+import { CLIError } from '@contentstack/cli-utilities';
+import { QueryParser } from '../../src/utils/query-parser';
+import { QueryExportConfig } from '../../src/types';
+
+describe('Query Parser Simple Tests', () => {
+  let queryParser: QueryParser;
+  let mockConfig: QueryExportConfig;
+
+  beforeEach(() => {
+    mockConfig = {
+      maxCTReferenceDepth: 20,
+      contentVersion: 2,
+      host: 'https://api.contentstack.io/v3',
+      exportDir: '/test/export',
+      stackApiKey: 'test-api-key',
+      managementToken: 'test-token',
+      query: '',
+      skipReferences: false,
+      skipDependencies: false,
+      branchName: 'main',
+      securedAssets: false,
+      isQueryBasedExport: true,
+      logsPath: '/test/logs',
+      dataPath: '/test/data',
+      modules: {
+        general: ['stack', 'locales', 'environments'],
+        queryable: ['content-types'],
+        dependent: ['global-fields', 'extensions', 'taxonomies'],
+        content: ['entries', 'assets'],
+        exportOrder: ['stack', 'content-types'],
+      },
+      queryConfig: {
+        maxRecursionDepth: 10,
+        batchSize: 100,
+        metadataFileName: '_query-meta.json',
+        validation: {
+          maxQueryDepth: 5,
+          maxArraySize: 1000,
+          allowedDateFormats: ['ISO8601'],
+        },
+      },
+      fetchConcurrency: 5,
+      writeConcurrency: 5,
+      apis: {
+        stacks: '/stacks/',
+        locales: '/locales/',
+        environments: '/environments/',
+        content_types: '/content_types/',
+        global_fields: '/global_fields/',
+        extensions: '/extensions/',
+        taxonomies: '/taxonomies/',
+        entries: '/entries/',
+        assets: '/assets/',
+      },
+    };
+
+    queryParser = new QueryParser(mockConfig);
+  });
+
+  describe('JSON string parsing and validation', () => {
+    it('should parse and validate a simple valid query', async () => {
+      const queryString = '{"modules": {"content-types": {"title": {"$exists": true}}}}';
+
+      const result = await queryParser.parse(queryString);
+
+      expect(result).to.be.an('object');
+      expect(result.modules).to.have.property('content-types');
+      expect(result.modules['content-types']).to.deep.equal({
+        title: { $exists: true },
+      });
+    });
+
+    it('should validate and reject queries without modules', async () => {
+      const queryString = '{"title": {"$exists": true}}';
+
+      try {
+        await queryParser.parse(queryString);
+        expect.fail('Expected validation error');
+      } catch (error) {
+        expect(error).to.be.instanceOf(CLIError);
+        expect(error.message).to.equal('The query must contain a "modules" object.');
+      }
+    });
+
+    it('should validate and reject queries with empty modules', async () => {
+      const queryString = '{"modules": {}}';
+
+      try {
+        await queryParser.parse(queryString);
+        expect.fail('Expected validation error');
+      } catch (error) {
+        expect(error).to.be.instanceOf(CLIError);
+        expect(error.message).to.equal('The query must contain at least one module.');
+      }
+    });
+
+    it('should validate and reject queries with non-queryable modules', async () => {
+      const queryString = '{"modules": {"invalid-module": {"title": {"$exists": true}}}}';
+
+      try {
+        await queryParser.parse(queryString);
+        expect.fail('Expected validation error');
+      } catch (error) {
+        expect(error).to.be.instanceOf(CLIError);
+        expect(error.message).to.include('Module "invalid-module" is not queryable');
+      }
+    });
+
+    it('should handle invalid JSON gracefully', async () => {
+      const invalidQuery = '{"modules": invalid json}';
+
+      try {
+        await queryParser.parse(invalidQuery);
+        expect.fail('Expected JSON parse error');
+      } catch (error) {
+        expect(error).to.be.instanceOf(CLIError);
+        expect(error.message).to.include('Invalid JSON query');
+      }
+    });
+
+    it('should handle complex valid queries', async () => {
+      const complexQuery = {
+        modules: {
+          'content-types': {
+            $and: [{ title: { $exists: true } }, { updated_at: { $gte: '2024-01-01' } }],
+          },
+        },
+      };
+
+      const result = await queryParser.parse(JSON.stringify(complexQuery));
+
+      expect(result).to.deep.equal(complexQuery);
+    });
+
+    it('should reject null queries', async () => {
+      try {
+        await queryParser.parse('null');
+        expect.fail('Expected validation error');
+      } catch (error) {
+        expect(error).to.be.instanceOf(CLIError);
+        expect(error.message).to.equal('The query must be a valid JSON object.');
+      }
+    });
+
+    it('should reject string queries', async () => {
+      try {
+        await queryParser.parse('"string query"');
+        expect.fail('Expected validation error');
+      } catch (error) {
+        expect(error).to.be.instanceOf(CLIError);
+        expect(error.message).to.equal('The query must be a valid JSON object.');
+      }
+    });
+  });
+});
diff --git a/packages/contentstack-query-export/test/unit/referenced-asset-handler.test.ts b/packages/contentstack-query-export/test/unit/referenced-asset-handler.test.ts
new file mode 100644
index 000000000..9c735ac0c
--- /dev/null
+++ b/packages/contentstack-query-export/test/unit/referenced-asset-handler.test.ts
@@ -0,0 +1,280 @@
+import { expect } from 'chai';
+import { AssetReferenceHandler } from '../../src/utils/referenced-asset-handler';
+import { QueryExportConfig } from '../../src/types';
+
+describe('Referenced Asset Handler Utilities', () => {
+  let handler: AssetReferenceHandler;
+  let mockConfig: QueryExportConfig;
+
+  beforeEach(() => {
+    mockConfig = {
+      maxCTReferenceDepth: 20,
+      contentVersion: 2,
+      host: 'https://api.contentstack.io/v3',
+      exportDir: '/test/export',
+      stackApiKey: 'test-api-key',
+      managementToken: 'test-token',
+      query: '',
+      skipReferences: false,
+      skipDependencies: false,
+      branchName: 'main',
+      securedAssets: false,
+      isQueryBasedExport: true,
+      logsPath: '/test/logs',
+      dataPath: '/test/data',
+      modules: {
+        general: ['stack', 'locales', 'environments'],
+        queryable: ['content-types'],
+        dependent: ['global-fields', 'extensions', 'taxonomies'],
+        content: ['entries', 'assets'],
+        exportOrder: ['stack', 'content-types'],
+      },
+      queryConfig: {
+        maxRecursionDepth: 10,
+        batchSize: 100,
+        metadataFileName: '_query-meta.json',
+        validation: {
+          maxQueryDepth: 5,
+          maxArraySize: 1000,
+          allowedDateFormats: ['ISO8601'],
+        },
+      },
+      fetchConcurrency: 5,
+      writeConcurrency: 5,
+      apis: {
+        stacks: '/stacks/',
+        locales: '/locales/',
+        environments: '/environments/',
+        content_types: '/content_types/',
+        global_fields: '/global_fields/',
+        extensions: '/extensions/',
+        taxonomies: '/taxonomies/',
+        entries: '/entries/',
+        assets: '/assets/',
+      },
+    };
+
+    handler = new AssetReferenceHandler(mockConfig);
+  });
+
+  describe('Asset UID extraction from content strings', () => {
+    it('should extract asset UIDs from HTML img tags', () => {
+      // Simulate JSON.stringify() content as it would appear in real usage
+      // Note: The regex expects asset_uid to be the first attribute after <img
+      const htmlContent = `
+        <p>Some content with images:</p>
+        <img asset_uid="asset123" src="some-url" alt="Image 1">
+        <img asset_uid="asset456" src="another-url" alt="Image 2">
+        <p>More content</p>
+        <img asset_uid="asset789" />
+      `;
+      const content = JSON.stringify({ field: htmlContent });
+
+      const result = (handler as any).extractAssetUIDsFromString(content);
+
+      expect(result).to.include('asset123');
+      expect(result).to.include('asset456');
+      expect(result).to.include('asset789');
+      expect(result.length).to.equal(3);
+    });
+
+    it('should extract asset UIDs from Contentstack asset URLs', () => {
+      const content = `
+        Check out this asset: "https://images.contentstack.io/v3/assets/stack123/asset456/version789/filename.jpg"
+        And this one: "https://eu-images.contentstack.io/v3/assets/stack456/asset123/version456/image.png"
+        Also: "https://assets.contentstack.com/v3/assets/stackabc/assetdef/versionghi/file.pdf"
+      `;
+
+      const result = (handler as any).extractAssetUIDsFromString(content);
+
+      expect(result).to.include('asset456');
+      expect(result).to.include('asset123');
+      expect(result).to.include('assetdef');
+      expect(result.length).to.equal(3);
+    });
+
+    it('should handle mixed asset references in content', () => {
+      const htmlContent = `
+        <div>
+          <img asset_uid="img_asset_123" src="test.jpg" />
+          <p>Link to: "https://images.contentstack.io/v3/assets/mystack/url_asset_456/v1/document.pdf"</p>
+          <img asset_uid="img_asset_789" />
+        </div>
+      `;
+      const content = JSON.stringify({ field: htmlContent });
+
+      const result = (handler as any).extractAssetUIDsFromString(content);
+
+      expect(result).to.include('img_asset_123');
+      expect(result).to.include('url_asset_456');
+      expect(result).to.include('img_asset_789');
+      expect(result.length).to.equal(3);
+    });
+
+    it('should handle Azure region URLs', () => {
+      const content = `
+        "https://azure-na-images.contentstack.io/v3/assets/stack123/azure_asset_123/v1/file.jpg"
+        "https://azure-eu-images.contentstack.io/v3/assets/stack456/azure_asset_456/v2/document.pdf"
+      `;
+
+      const result = (handler as any).extractAssetUIDsFromString(content);
+
+      expect(result).to.include('azure_asset_123');
+      expect(result).to.include('azure_asset_456');
+      expect(result.length).to.equal(2);
+    });
+
+    it('should handle GCP region URLs', () => {
+      const content = `
+        "https://gcp-na-images.contentstack.io/v3/assets/stack123/gcp_asset_123/v1/file.jpg"
+        "https://gcp-eu-images.contentstack.io/v3/assets/stack456/gcp_asset_456/v2/document.pdf"
+      `;
+
+      const result = (handler as any).extractAssetUIDsFromString(content);
+
+      expect(result).to.include('gcp_asset_123');
+      expect(result).to.include('gcp_asset_456');
+      expect(result.length).to.equal(2);
+    });
+
+    it('should return empty array for content without assets', () => {
+      const content = `
+        <div>
+          <h1>Title</h1>
+          <p>Just some text content without any asset references.</p>
+          <a href="https://example.com">External link</a>
+        </div>
+      `;
+
+      const result = (handler as any).extractAssetUIDsFromString(content);
+
+      expect(result).to.be.an('array');
+      expect(result.length).to.equal(0);
+    });
+
+    it('should handle malformed asset references gracefully', () => {
+      const content = `
+        <img asset_uid="" src="test.jpg" />
+        <img asset_uid src="test2.jpg" />
+        "https://images.contentstack.io/v3/assets/"
+        "https://images.contentstack.io/v3/assets/stack123/"
+      `;
+
+      const result = (handler as any).extractAssetUIDsFromString(content);
+
+      // Should not include empty or malformed UIDs
+      expect(result).to.be.an('array');
+      expect(result.length).to.equal(0);
+    });
+
+    it('should deduplicate asset UIDs from same content', () => {
+      const htmlContent = `
+        <img asset_uid="duplicate_asset" src="image1.jpg" />
+        <img asset_uid="duplicate_asset" src="image2.jpg" />
+        "https://images.contentstack.io/v3/assets/stack123/duplicate_asset/v1/file.jpg"
+        <img asset_uid="unique_asset" src="image3.jpg" />
+      `;
+      const content = JSON.stringify({ field: htmlContent });
+
+      const result = (handler as any).extractAssetUIDsFromString(content);
+
+      expect(result).to.include('duplicate_asset');
+      expect(result).to.include('unique_asset');
+      expect(result.length).to.equal(2);
+
+      // Check that duplicate_asset appears only once
+      const duplicateCount = result.filter((uid: any) => uid === 'duplicate_asset').length;
+      expect(duplicateCount).to.equal(1);
+    });
+
+    it('should handle escaped quotes in HTML', () => {
+      const content = `<img asset_uid=\\"escaped_asset_123\\" src=\\"test.jpg\\" />`;
+
+      const result = (handler as any).extractAssetUIDsFromString(content);
+
+      expect(result).to.include('escaped_asset_123');
+      expect(result.length).to.equal(1);
+    });
+
+    it('should handle JSON-stringified content with asset references', () => {
+      const jsonContent = JSON.stringify({
+        content: '<img asset_uid="json_asset_123" src="test.jpg" />',
+        url: 'https://images.contentstack.io/v3/assets/stack123/json_asset_456/v1/file.jpg',
+      });
+
+      const result = (handler as any).extractAssetUIDsFromString(jsonContent);
+
+      expect(result).to.include('json_asset_123');
+      expect(result).to.include('json_asset_456');
+      expect(result.length).to.equal(2);
+    });
+
+    it('should handle content with special characters in asset UIDs', () => {
+      const htmlContent = `
+        <img asset_uid="asset-with-dashes-123" src="test1.jpg" />
+        <img asset_uid="asset_with_underscores_456" src="test2.jpg" />
+        <img asset_uid="asset123ABC" src="test3.jpg" />
+      `;
+      const content = JSON.stringify({ field: htmlContent });
+
+      const result = (handler as any).extractAssetUIDsFromString(content);
+
+      expect(result).to.include('asset-with-dashes-123');
+      expect(result).to.include('asset_with_underscores_456');
+      expect(result).to.include('asset123ABC');
+      expect(result.length).to.equal(3);
+    });
+
+    it('should handle large content strings efficiently', () => {
+      // Create a large content string with asset references
+      const assetReferences: string[] = [];
+      let htmlContent = '<div>';
+
+      for (let i = 0; i < 100; i++) {
+        const assetUID = `asset_${i}`;
+        assetReferences.push(assetUID);
+        htmlContent += `<img asset_uid="${assetUID}" src="image${i}.jpg" />`;
+      }
+      htmlContent += '</div>';
+
+      const content = JSON.stringify({ field: htmlContent });
+
+      const result = (handler as any).extractAssetUIDsFromString(content);
+
+      expect(result.length).to.equal(100);
+      assetReferences.forEach((uid) => {
+        expect(result).to.include(uid);
+      });
+    });
+
+    it('should handle contentstack.com domain URLs', () => {
+      const content = `
+        "https://assets.contentstack.com/v3/assets/stack123/com_asset_123/v1/file.jpg"
+        "https://images.contentstack.com/v3/assets/stack456/com_asset_456/v2/image.png"
+      `;
+
+      const result = (handler as any).extractAssetUIDsFromString(content);
+
+      expect(result).to.include('com_asset_123');
+      expect(result).to.include('com_asset_456');
+      expect(result.length).to.equal(2);
+    });
+  });
+
+  describe('Constructor and initialization', () => {
+    it('should initialize with correct export directory path', () => {
+      expect(handler).to.be.instanceOf(AssetReferenceHandler);
+
+      // Check that entriesDir is set correctly
+      const entriesDir = (handler as any).entriesDir;
+      expect(entriesDir).to.include('/test/export');
+      expect(entriesDir).to.include('entries');
+    });
+
+    it('should store export configuration', () => {
+      const config = (handler as any).exportQueryConfig;
+      expect(config).to.equal(mockConfig);
+      expect(config.exportDir).to.equal('/test/export');
+    });
+  });
+});
diff --git a/packages/contentstack-query-export/test/unit/test-cases-summary.txt b/packages/contentstack-query-export/test/unit/test-cases-summary.txt
new file mode 100644
index 000000000..a6b13def1
--- /dev/null
+++ b/packages/contentstack-query-export/test/unit/test-cases-summary.txt
@@ -0,0 +1,282 @@
+CLI QUERY EXPORT - UNIT TEST CASES SUMMARY
+===========================================
+Total: 131 Test Cases Across 8 Test Files
+Coverage: 69.33% Overall | Core: 89.75% | Utils: 55.85%
+
+═══════════════════════════════════════════════════════════════════
+
+📁 MODULE-EXPORTER.TEST.TS (32 Test Cases)
+═══════════════════════════════════════════════════════════════════
+
+🔧 Constructor (2 tests)
+- ✅ should initialize ModuleExporter with correct configuration
+- ✅ should initialize empty exported modules array
+
+🛠️ buildExportCommand (14 tests)
+- ✅ should build basic export command with required parameters
+- ✅ should include branch when specified in config
+- ✅ should include branch from options over config
+- ✅ should include query when provided in options
+- ✅ should include secured assets flag when enabled in config
+- ✅ should include secured assets from options over config
+- ✅ should use alias over management token when provided
+- ✅ should include external config path when specified
+- ✅ should use custom config path from options
+- ✅ should use custom directory from options
+- ✅ should handle missing optional parameters
+- ✅ should build different commands for different modules
+- ✅ should handle complex query structures
+
+📤 exportModule (7 tests)
+- ✅ should export module successfully
+- ✅ should pass correct command to ExportCommand.run
+- ✅ should track exported modules without duplicates
+- ✅ should handle export command errors
+- ✅ should export with query options
+- ✅ should export with all options
+- ✅ should handle different module types
+
+📖 readExportedData (2 tests)
+- ✅ should handle file reading logic (private method testing)
+- ✅ should handle JSON parsing scenarios
+
+📋 getExportedModules (3 tests)
+- ✅ should return empty array initially
+- ✅ should return copy of exported modules array
+- ✅ should reflect modules added through exportModule
+
+❌ error handling (3 tests)
+- ✅ should handle export command initialization errors
+- ✅ should handle malformed configuration gracefully
+- ✅ should handle missing stack API client gracefully
+
+🔄 integration scenarios (3 tests)
+- ✅ should handle sequential module exports
+- ✅ should handle concurrent module exports
+- ✅ should handle mixed success and failure scenarios
+
+═══════════════════════════════════════════════════════════════════
+
+📁 QUERY-EXECUTOR.TEST.TS (35 Test Cases)
+═══════════════════════════════════════════════════════════════════
+
+🔧 constructor (3 tests)
+- ✅ should initialize QueryExporter with correct configuration
+- ✅ should create QueryParser instance with correct config
+- ✅ should create ModuleExporter instance
+
+▶️ execute (5 tests)
+- ✅ should execute the complete export workflow
+- ✅ should call methods in correct order
+- ✅ should pass parsed query to exportQueriedModule
+- ✅ should handle query parsing errors
+- ✅ should handle export errors and propagate them
+
+🌐 exportGeneralModules (3 tests)
+- ✅ should export all general modules
+- ✅ should handle empty general modules array
+- ✅ should handle module export errors
+
+🔍 exportQueriedModule (3 tests)
+- ✅ should export queryable modules with query
+- ✅ should skip non-queryable modules
+- ✅ should handle empty modules in query
+
+🔗 exportReferencedContentTypes (3 tests)
+- ✅ should handle no referenced content types found
+- ✅ should export new referenced content types
+- ✅ should handle file system errors gracefully
+
+🧩 exportDependentModules (4 tests)
+- ✅ should export all dependency types when found
+- ✅ should skip empty dependency sets
+- ✅ should handle partial dependencies
+- ✅ should handle dependencies extraction errors
+
+📝 exportContentModules (4 tests)
+- ✅ should export entries and then assets
+- ✅ should include delay before asset export
+- ✅ should handle entries export errors
+- ✅ should handle assets export errors
+
+📋 exportEntries (2 tests)
+- ✅ should export entries module
+- ✅ should handle entries export errors
+
+🖼️ exportReferencedAssets (4 tests)
+- ✅ should export referenced assets when found
+- ✅ should skip export when no assets found
+- ✅ should handle asset extraction errors
+- ✅ should handle asset export errors
+
+═══════════════════════════════════════════════════════════════════
+
+📁 COMMON-HELPER.TEST.TS (4 Test Cases)
+═══════════════════════════════════════════════════════════════════
+
+🔑 askAPIKey (4 tests)
+- ✅ should prompt user for API key and return the response
+- ✅ should handle empty API key input
+- ✅ should handle inquire errors
+- ✅ should validate the inquire call structure
+
+═══════════════════════════════════════════════════════════════════
+
+📁 CONFIG-HANDLER.TEST.TS (16 Test Cases)
+═══════════════════════════════════════════════════════════════════
+
+⚙️ setupQueryExportConfig
+  📁 with minimal flags (1 test)
+  - ✅ should create config with default values
+  
+  📂 with custom data directory (1 test)
+  - ✅ should use custom data directory when provided
+  
+  ⏭️ with skip flags (1 test)
+  - ✅ should set skip flags when provided
+  
+  🌿 with branch name (1 test)
+  - ✅ should include branch name when provided
+  
+  📄 external config path (1 test)
+  - ✅ should set external config path correctly
+  
+  🔐 stack API key handling (2 tests)
+  - ✅ should use provided stack API key
+  - ✅ should handle empty stack API key
+  
+  🏗️ configuration object structure (2 tests)
+  - ✅ should include all required configuration properties
+  - ✅ should set isQueryBasedExport to true
+  
+  ❌ error scenarios (2 tests)
+  - ✅ should handle missing query parameter
+  - ✅ should handle invalid flag types
+  
+  📍 path handling (2 tests)
+  - ✅ should ensure paths are consistent
+  - ✅ should handle absolute paths
+  
+  🔑 askAPIKey integration (2 tests)
+  - ✅ should call askAPIKey when no stack API key provided
+  - ✅ should handle askAPIKey returning non-string value
+
+═══════════════════════════════════════════════════════════════════
+
+📁 CONTENT-TYPE-HELPER.TEST.TS (15 Test Cases)
+═══════════════════════════════════════════════════════════════════
+
+🔗 extractReferencedContentTypes (11 tests)
+- ✅ should extract reference field targets
+- ✅ should exclude sys_assets from references
+- ✅ should handle group fields with nested schemas
+- ✅ should handle global fields with nested schemas
+- ✅ should handle blocks with nested schemas
+- ✅ should handle JSON RTE with embedded entries
+- ✅ should handle Text RTE with embedded entries
+- ✅ should handle content types without schemas
+- ✅ should return empty array for content types with no references
+- ✅ should handle complex nested structures
+- ✅ should remove duplicates from referenced content types
+
+🆕 filterNewlyFetchedContentTypes (4 tests)
+- ✅ should filter out content types that were previously fetched
+- ✅ should return all content types when no previous UIDs
+- ✅ should return empty array when all content types were previously fetched
+- ✅ should handle empty content types array
+
+═══════════════════════════════════════════════════════════════════
+
+📁 DEPENDENCY-RESOLVER.TEST.TS (10 Test Cases)
+═══════════════════════════════════════════════════════════════════
+
+🔗 Schema dependency extraction logic (10 tests)
+- ✅ should extract global field dependencies from schema
+- ✅ should extract extension dependencies from schema
+- ✅ should extract taxonomy dependencies from schema
+- ✅ should handle group fields with nested dependencies
+- ✅ should handle block fields with nested dependencies
+- ✅ should handle complex nested structures
+- ✅ should ignore fields without dependency information
+- ✅ should handle taxonomies without taxonomy_uid gracefully
+- ✅ should handle mixed dependency types in single schema
+- ✅ should handle empty schema arrays
+
+═══════════════════════════════════════════════════════════════════
+
+📁 QUERY-PARSER-SIMPLE.TEST.TS (8 Test Cases)
+═══════════════════════════════════════════════════════════════════
+
+🔍 JSON string parsing and validation (8 tests)
+- ✅ should parse and validate a simple valid query
+- ✅ should validate and reject queries without modules
+- ✅ should validate and reject queries with empty modules
+- ✅ should validate and reject queries with non-queryable modules
+- ✅ should handle invalid JSON gracefully
+- ✅ should handle complex valid queries
+- ✅ should reject null queries
+- ✅ should reject string queries
+
+═══════════════════════════════════════════════════════════════════
+
+📁 REFERENCED-ASSET-HANDLER.TEST.TS (15 Test Cases)
+═══════════════════════════════════════════════════════════════════
+
+🖼️ Asset UID extraction from content strings (13 tests)
+- ✅ should extract asset UIDs from HTML img tags
+- ✅ should extract asset UIDs from Contentstack asset URLs
+- ✅ should handle mixed asset references in content
+- ✅ should handle Azure region URLs
+- ✅ should handle GCP region URLs
+- ✅ should return empty array for content without assets
+- ✅ should handle malformed asset references gracefully
+- ✅ should deduplicate asset UIDs from same content
+- ✅ should handle escaped quotes in HTML
+- ✅ should handle JSON-stringified content with asset references
+- ✅ should handle content with special characters in asset UIDs
+- ✅ should handle large content strings efficiently
+- ✅ should handle contentstack.com domain URLs
+
+🏗️ Constructor and initialization (2 tests)
+- ✅ should initialize with correct export directory path
+- ✅ should store export configuration
+
+═══════════════════════════════════════════════════════════════════
+
+📊 SUMMARY STATISTICS
+═══════════════════════════════════════════════════════════════════
+
+📈 Test Distribution:
+- Core Modules: 67 tests (51.1%) - QueryExporter + ModuleExporter
+- Utils Modules: 64 tests (48.9%) - All utility functions
+
+🎯 Coverage Breakdown:
+- query-executor.ts: 100% coverage (PERFECT!)
+- module-exporter.ts: 70.17% coverage
+- content-type-helper.ts: 100% coverage (PERFECT!)
+- common-helper.ts: 100% coverage (PERFECT!)
+- file-helper.ts: 100% coverage (PERFECT!)
+- query-parser.ts: 81.48% coverage
+- config-handler.ts: 70% coverage
+- dependency-resolver.ts: 70% coverage
+- referenced-asset-handler.ts: 30.64% coverage
+- logger.ts: 18.03% coverage
+
+⚡ Performance:
+- Execution Time: ~160ms
+- Exit Code: 0 (Perfect CI/CD compatibility)
+- No interactive prompts (Non-blocking)
+
+🏆 Key Testing Achievements:
+- Complete export workflow orchestration
+- Comprehensive command building logic
+- Error handling and recovery patterns
+- Business logic validation
+- Edge case coverage
+- Integration scenario testing
+- TypeScript type safety validation
+
+═══════════════════════════════════════════════════════════════════
+Generated: $(date)
+CLI Query Export Plugin - Contentstack
+═══════════════════════════════════════════════════════════════════ 
\ No newline at end of file
diff --git a/packages/contentstack-query-export/tsconfig.json b/packages/contentstack-query-export/tsconfig.json
new file mode 100644
index 000000000..513662339
--- /dev/null
+++ b/packages/contentstack-query-export/tsconfig.json
@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "declaration": true,
+    "importHelpers": true,
+    "module": "commonjs",
+    "outDir": "lib",
+    "rootDir": "src",
+    "strict": false,
+    "target": "es2017",
+    "allowJs": true,
+    "skipLibCheck": true,
+    "sourceMap": false,
+    "esModuleInterop": true,
+    "noImplicitAny": true,
+    "lib": [
+      "ES2019",
+      "es2020.promise"
+    ],
+    "strictPropertyInitialization": false,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": [
+    "src/**/*",
+    "types/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "lib"
+  ]
+}
\ No newline at end of file
diff --git a/packages/contentstack-query-export/types/index.d.ts b/packages/contentstack-query-export/types/index.d.ts
new file mode 100644
index 000000000..68a9e1353
--- /dev/null
+++ b/packages/contentstack-query-export/types/index.d.ts
@@ -0,0 +1 @@
+declare module 'big-json';
diff --git a/packages/contentstack-seed/package.json b/packages/contentstack-seed/package.json
index 3a9462991..7a65f0d6b 100644
--- a/packages/contentstack-seed/package.json
+++ b/packages/contentstack-seed/package.json
@@ -20,8 +20,7 @@
     "@types/node": "^18.11.9",
     "@types/tar": "^6.1.13",
     "@types/tmp": "^0.2.6",
-    "axios": "^1.15.1",
-    "eslint": "^8.57.1",
+    "eslint": "^9.26.0",
     "eslint-config-oclif": "^6.0.137",
     "eslint-config-oclif-typescript": "^3.1.14",
     "jest": "^29.7.0",
@@ -71,4 +70,4 @@
     "compile": "tsc -b tsconfig.json",
     "build": "pnpm compile && oclif manifest && oclif readme"
   }
-}
+}
\ No newline at end of file
diff --git a/packages/contentstack-variants/package.json b/packages/contentstack-variants/package.json
index ce90783c5..f161a6e98 100644
--- a/packages/contentstack-variants/package.json
+++ b/packages/contentstack-variants/package.json
@@ -19,7 +19,6 @@
   "license": "MIT",
   "devDependencies": {
     "@contentstack/cli-dev-dependencies": "^2.0.0-beta.0",
-    "@oclif/plugin-help": "^6.2.28",
     "@oclif/test": "^4.1.18",
     "@types/node": "^20.19.39",
     "mocha": "^10.8.2",
@@ -30,7 +29,6 @@
   "dependencies": {
     "@contentstack/cli-utilities": "~2.0.0-beta.7",
     "@oclif/core": "^4.3.0",
-    "@oclif/plugin-help": "^6.2.28",
     "lodash": "^4.18.1",
     "mkdirp": "^1.0.4",
     "winston": "^3.19.0"
diff --git a/packages/contentstack-variants/src/types/export-config.ts b/packages/contentstack-variants/src/types/export-config.ts
index 6233bba88..5687e1f68 100644
--- a/packages/contentstack-variants/src/types/export-config.ts
+++ b/packages/contentstack-variants/src/types/export-config.ts
@@ -17,6 +17,7 @@ export type Modules =
   | 'content-types'
   | 'custom-roles'
   | 'workflows'
+  | 'publishing-rules'
   | 'labels'
   | 'marketplace-apps'
   | 'taxonomies'
@@ -87,6 +88,13 @@ export interface DefaultConfig {
       invalidKeys: string[];
       dependencies?: Modules[];
     };
+    'publishing-rules': {
+      dirName: string;
+      fileName: string;
+      invalidKeys: string[];
+      dependencies?: Modules[];
+      limit?: number;
+    };
     globalfields: {
       dirName: string;
       fileName: string;
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index c04a03202..372e622d5 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -8,6 +8,7 @@ overrides:
   tmp: 0.2.4
   follow-redirects: 1.16.0
   axios: 1.15.2
+  uuid: 14.0.0
 
 importers:
 
@@ -18,13 +19,13 @@ importers:
         version: 9.1.7
       pnpm:
         specifier: ^10.28.0
-        version: 10.33.0
+        version: 10.33.4
 
   packages/contentstack-asset-management:
     dependencies:
       '@contentstack/cli-utilities':
         specifier: ~2.0.0-beta.5
-        version: 2.0.0-beta.7(@types/node@20.19.39)
+        version: 2.0.0-beta.7(@types/node@20.19.41)
     devDependencies:
       '@types/chai':
         specifier: ^4.3.11
@@ -34,7 +35,7 @@ importers:
         version: 10.0.10
       '@types/node':
         specifier: ^20.17.50
-        version: 20.19.39
+        version: 20.19.41
       '@types/sinon':
         specifier: ^17.0.2
         version: 17.0.4
@@ -46,7 +47,7 @@ importers:
         version: 8.57.1
       eslint-config-oclif:
         specifier: ^6.0.68
-        version: 6.0.159(eslint@8.57.1)(typescript@5.9.3)
+        version: 6.0.164(eslint@8.57.1)(typescript@5.9.3)
       mocha:
         specifier: ^10.8.2
         version: 10.8.2
@@ -55,7 +56,7 @@ importers:
         version: 15.1.0
       oclif:
         specifier: ^4.17.46
-        version: 4.23.0(@types/node@20.19.39)
+        version: 4.23.0(@types/node@20.19.41)
       sinon:
         specifier: ^17.0.1
         version: 17.0.2
@@ -64,7 +65,7 @@ importers:
         version: 0.5.21
       ts-node:
         specifier: ^10.9.2
-        version: 10.9.2(@types/node@20.19.39)(typescript@5.9.3)
+        version: 10.9.2(@types/node@20.19.41)(typescript@5.9.3)
       typescript:
         specifier: ^5.8.3
         version: 5.9.3
@@ -73,16 +74,13 @@ importers:
     dependencies:
       '@contentstack/cli-command':
         specifier: ~2.0.0-beta.6
-        version: 2.0.0-beta.6(@types/node@20.19.39)
+        version: 2.0.0-beta.6(@types/node@20.19.41)
       '@contentstack/cli-utilities':
         specifier: ~2.0.0-beta.7
-        version: 2.0.0-beta.7(@types/node@20.19.39)
+        version: 2.0.0-beta.7(@types/node@20.19.41)
       '@oclif/core':
         specifier: ^4.3.0
-        version: 4.10.5
-      '@oclif/plugin-help':
-        specifier: ^6.2.28
-        version: 6.2.44
+        version: 4.11.2
       chalk:
         specifier: ^5.6.2
         version: 5.6.2
@@ -91,20 +89,17 @@ importers:
         version: 4.3.6
       fs-extra:
         specifier: ^11.3.0
-        version: 11.3.4
+        version: 11.3.5
       lodash:
         specifier: ^4.18.1
         version: 4.18.1
-      uuid:
-        specifier: ^9.0.1
-        version: 9.0.1
       winston:
         specifier: ^3.19.0
         version: 3.19.0
     devDependencies:
       '@oclif/test':
         specifier: ^4.1.18
-        version: 4.1.18(@oclif/core@4.10.5)
+        version: 4.1.18(@oclif/core@4.11.2)
       '@types/chai':
         specifier: ^4.3.20
         version: 4.3.20
@@ -116,22 +111,19 @@ importers:
         version: 10.0.10
       '@types/node':
         specifier: ^20.17.50
-        version: 20.19.39
-      '@types/uuid':
-        specifier: ^9.0.8
-        version: 9.0.8
+        version: 20.19.41
       chai:
         specifier: ^4.5.0
         version: 4.5.0
       eslint:
-        specifier: ^8.57.1
-        version: 8.57.1
+        specifier: ^9.26.0
+        version: 9.39.4
       eslint-config-oclif:
         specifier: ^6.0.62
-        version: 6.0.159(eslint@8.57.1)(typescript@5.9.3)
+        version: 6.0.164(eslint@9.39.4)(typescript@5.9.3)
       eslint-config-oclif-typescript:
         specifier: ^3.1.14
-        version: 3.1.14(eslint@8.57.1)(typescript@5.9.3)
+        version: 3.1.14(eslint@9.39.4)(typescript@5.9.3)
       mocha:
         specifier: ^10.8.2
         version: 10.8.2
@@ -140,7 +132,7 @@ importers:
         version: 15.1.0
       oclif:
         specifier: ^4.17.46
-        version: 4.23.0(@types/node@20.19.39)
+        version: 4.23.0(@types/node@20.19.41)
       shx:
         specifier: ^0.4.0
         version: 0.4.0
@@ -149,7 +141,7 @@ importers:
         version: 21.1.2
       ts-node:
         specifier: ^10.9.2
-        version: 10.9.2(@types/node@20.19.39)(typescript@5.9.3)
+        version: 10.9.2(@types/node@20.19.41)(typescript@5.9.3)
       typescript:
         specifier: ^5.8.3
         version: 5.9.3
@@ -170,23 +162,20 @@ importers:
         version: 2.0.0-beta.7(@types/node@18.19.130)
       '@oclif/core':
         specifier: ^4.3.0
-        version: 4.10.5
-      '@oclif/plugin-help':
-        specifier: ^6.2.37
-        version: 6.2.44
+        version: 4.11.2
       inquirer:
         specifier: 12.11.1
         version: 12.11.1(@types/node@18.19.130)
       mkdirp:
-        specifier: ^1.0.4
-        version: 1.0.4
+        specifier: ^2.1.6
+        version: 2.1.6
       tar:
         specifier: ^7.5.11
-        version: 7.5.13
+        version: 7.5.15
     devDependencies:
       '@oclif/test':
         specifier: ^4.1.18
-        version: 4.1.18(@oclif/core@4.10.5)
+        version: 4.1.18(@oclif/core@4.11.2)
       '@types/inquirer':
         specifier: ^9.0.8
         version: 9.0.9
@@ -203,14 +192,8 @@ importers:
         specifier: ^4.5.0
         version: 4.5.0
       eslint:
-        specifier: ^8.57.1
-        version: 8.57.1
-      eslint-config-oclif:
-        specifier: ^6.0.62
-        version: 6.0.159(eslint@8.57.1)(typescript@5.9.3)
-      eslint-config-oclif-typescript:
-        specifier: ^3.1.14
-        version: 3.1.14(eslint@8.57.1)(typescript@5.9.3)
+        specifier: ^9.26.0
+        version: 9.39.4
       mocha:
         specifier: 10.8.2
         version: 10.8.2
@@ -234,16 +217,13 @@ importers:
     dependencies:
       '@contentstack/cli-command':
         specifier: ~2.0.0-beta.6
-        version: 2.0.0-beta.6(@types/node@22.19.17)
+        version: 2.0.0-beta.6(@types/node@22.19.19)
       '@contentstack/cli-utilities':
         specifier: ~2.0.0-beta.7
-        version: 2.0.0-beta.7(@types/node@22.19.17)
+        version: 2.0.0-beta.7(@types/node@22.19.19)
       '@oclif/core':
         specifier: ^4.3.0
-        version: 4.10.5
-      '@oclif/plugin-help':
-        specifier: ^6.2.28
-        version: 6.2.44
+        version: 4.11.2
       chalk:
         specifier: ^5.6.2
         version: 5.6.2
@@ -254,12 +234,6 @@ importers:
         specifier: ^4.18.1
         version: 4.18.1
     devDependencies:
-      '@contentstack/cli-dev-dependencies':
-        specifier: ~2.0.0-beta.0
-        version: 2.0.0-beta.0
-      '@types/flat':
-        specifier: ^5.0.5
-        version: 5.0.5
       chai:
         specifier: ^4.5.0
         version: 4.5.0
@@ -270,11 +244,11 @@ importers:
         specifier: ^9.0.0
         version: 9.0.0
       eslint:
-        specifier: ^8.57.1
-        version: 8.57.1
+        specifier: ^9.26.0
+        version: 9.39.4
       eslint-config-oclif:
         specifier: ^6.0.62
-        version: 6.0.159(eslint@8.57.1)(typescript@4.9.5)
+        version: 6.0.164(eslint@9.39.4)(typescript@4.9.5)
       mocha:
         specifier: 10.8.2
         version: 10.8.2
@@ -283,13 +257,13 @@ importers:
         version: 15.1.0
       oclif:
         specifier: ^4.17.46
-        version: 4.23.0(@types/node@22.19.17)
+        version: 4.23.0(@types/node@22.19.19)
       sinon:
         specifier: ^21.0.1
         version: 21.1.2
       ts-node:
         specifier: ^10.9.2
-        version: 10.9.2(@types/node@22.19.17)(typescript@4.9.5)
+        version: 10.9.2(@types/node@22.19.19)(typescript@4.9.5)
       typescript:
         specifier: ^4.9.5
         version: 4.9.5
@@ -313,10 +287,7 @@ importers:
         version: 2.0.0-beta.7(@types/node@18.19.130)
       '@oclif/core':
         specifier: ^4.3.0
-        version: 4.10.5
-      '@oclif/plugin-help':
-        specifier: ^6.2.28
-        version: 6.2.44
+        version: 4.11.2
       chalk:
         specifier: ^5.6.2
         version: 5.6.2
@@ -341,7 +312,7 @@ importers:
     devDependencies:
       '@oclif/test':
         specifier: ^4.1.18
-        version: 4.1.18(@oclif/core@4.10.5)
+        version: 4.1.18(@oclif/core@4.11.2)
       '@types/chai':
         specifier: ^4.3.0
         version: 4.3.20
@@ -356,16 +327,16 @@ importers:
         version: 10.0.20
       '@typescript-eslint/eslint-plugin':
         specifier: ^5.62.0
-        version: 5.62.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1)(typescript@5.9.3)
+        version: 5.62.0(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@5.9.3))(eslint@9.39.4)(typescript@5.9.3)
       chai:
         specifier: ^4.5.0
         version: 4.5.0
       eslint:
-        specifier: ^8.57.1
-        version: 8.57.1
+        specifier: ^9.26.0
+        version: 9.39.4
       eslint-config-oclif:
         specifier: ^6.0.62
-        version: 6.0.159(eslint@8.57.1)(typescript@5.9.3)
+        version: 6.0.164(eslint@9.39.4)(typescript@5.9.3)
       mocha:
         specifier: ^10.8.2
         version: 10.8.2
@@ -392,16 +363,16 @@ importers:
         version: link:../contentstack-asset-management
       '@contentstack/cli-command':
         specifier: ~2.0.0-beta.6
-        version: 2.0.0-beta.6(@types/node@22.19.17)
+        version: 2.0.0-beta.6(@types/node@22.19.19)
       '@contentstack/cli-utilities':
         specifier: ~2.0.0-beta.7
-        version: 2.0.0-beta.7(@types/node@22.19.17)
+        version: 2.0.0-beta.7(@types/node@22.19.19)
       '@contentstack/cli-variants':
         specifier: ~2.0.0-beta.12
         version: link:../contentstack-variants
       '@oclif/core':
         specifier: ^4.8.0
-        version: 4.10.5
+        version: 4.11.2
       async:
         specifier: ^3.2.6
         version: 3.2.6
@@ -435,19 +406,19 @@ importers:
     devDependencies:
       '@contentstack/cli-auth':
         specifier: ~2.0.0-beta.9
-        version: 2.0.0-beta.11(@types/node@22.19.17)
+        version: 2.0.0-beta.11(@types/node@22.19.19)
       '@contentstack/cli-config':
         specifier: ~2.0.0-beta.5
-        version: 2.0.0-beta.8(@types/node@22.19.17)
+        version: 2.0.0-beta.8(@types/node@22.19.19)
       '@contentstack/cli-dev-dependencies':
         specifier: ~2.0.0-beta.0
         version: 2.0.0-beta.0
       '@oclif/plugin-help':
         specifier: ^6.2.28
-        version: 6.2.44
+        version: 6.2.48
       '@oclif/test':
         specifier: ^4.1.18
-        version: 4.1.18(@oclif/core@4.10.5)
+        version: 4.1.18(@oclif/core@4.11.2)
       '@types/big-json':
         specifier: ^3.2.5
         version: 3.2.5
@@ -476,11 +447,8 @@ importers:
         specifier: ^9.0.0
         version: 9.0.0
       eslint:
-        specifier: ^8.57.1
-        version: 8.57.1
-      eslint-config-oclif:
-        specifier: ^6.0.68
-        version: 6.0.159(eslint@8.57.1)(typescript@4.9.5)
+        specifier: ^9.26.0
+        version: 9.39.4
       mocha:
         specifier: 10.8.2
         version: 10.8.2
@@ -489,7 +457,7 @@ importers:
         version: 15.1.0
       oclif:
         specifier: ^4.17.46
-        version: 4.23.0(@types/node@22.19.17)
+        version: 4.23.0(@types/node@22.19.19)
       sinon:
         specifier: ^17.0.1
         version: 17.0.2
@@ -498,7 +466,7 @@ importers:
         version: 0.5.21
       ts-node:
         specifier: ^10.9.2
-        version: 10.9.2(@types/node@22.19.17)(typescript@4.9.5)
+        version: 10.9.2(@types/node@22.19.19)(typescript@4.9.5)
       typescript:
         specifier: ^4.9.5
         version: 4.9.5
@@ -507,23 +475,20 @@ importers:
     dependencies:
       '@contentstack/cli-command':
         specifier: ~2.0.0-beta.6
-        version: 2.0.0-beta.6(@types/node@20.19.39)
+        version: 2.0.0-beta.6(@types/node@20.19.41)
       '@contentstack/cli-utilities':
         specifier: ~2.0.0-beta.7
-        version: 2.0.0-beta.7(@types/node@20.19.39)
+        version: 2.0.0-beta.7(@types/node@20.19.41)
       '@oclif/core':
         specifier: ^4.8.0
-        version: 4.10.5
-      '@oclif/plugin-help':
-        specifier: ^6.2.32
-        version: 6.2.44
+        version: 4.11.2
       fast-csv:
         specifier: ^4.3.6
         version: 4.3.6
     devDependencies:
       '@oclif/test':
         specifier: ^4.1.18
-        version: 4.1.18(@oclif/core@4.10.5)
+        version: 4.1.18(@oclif/core@4.11.2)
       '@types/chai':
         specifier: ^4.3.20
         version: 4.3.20
@@ -535,37 +500,34 @@ importers:
         version: 10.0.10
       '@types/node':
         specifier: ^20.17.50
-        version: 20.19.39
+        version: 20.19.41
       chai:
         specifier: ^4.5.0
         version: 4.5.0
       eslint:
-        specifier: ^8.57.1
-        version: 8.57.1
+        specifier: ^9.26.0
+        version: 9.39.4
       eslint-config-oclif:
         specifier: ^6.0.62
-        version: 6.0.159(eslint@8.57.1)(typescript@5.9.3)
+        version: 6.0.164(eslint@9.39.4)(typescript@5.9.3)
       eslint-config-oclif-typescript:
         specifier: ^3.1.14
-        version: 3.1.14(eslint@8.57.1)(typescript@5.9.3)
+        version: 3.1.14(eslint@9.39.4)(typescript@5.9.3)
       mocha:
         specifier: ^10.8.2
         version: 10.8.2
-      nock:
-        specifier: ^13.5.6
-        version: 13.5.6
       nyc:
         specifier: ^15.1.0
         version: 15.1.0
       oclif:
         specifier: ^4.17.46
-        version: 4.23.0(@types/node@20.19.39)
+        version: 4.23.0(@types/node@20.19.41)
       sinon:
         specifier: ^21.0.1
         version: 21.1.2
       ts-node:
         specifier: ^10.9.2
-        version: 10.9.2(@types/node@20.19.39)(typescript@5.9.3)
+        version: 10.9.2(@types/node@20.19.41)(typescript@5.9.3)
       typescript:
         specifier: ^5.8.3
         version: 5.9.3
@@ -589,7 +551,7 @@ importers:
         version: link:../contentstack-variants
       '@oclif/core':
         specifier: ^4.3.0
-        version: 4.10.5
+        version: 4.11.2
       big-json:
         specifier: ^3.2.0
         version: 3.2.0
@@ -604,7 +566,7 @@ importers:
         version: 4.4.3(supports-color@8.1.1)
       fs-extra:
         specifier: ^11.3.3
-        version: 11.3.4
+        version: 11.3.5
       lodash:
         specifier: ^4.18.1
         version: 4.18.1
@@ -620,16 +582,13 @@ importers:
       promise-limit:
         specifier: ^2.7.0
         version: 2.7.0
-      uuid:
-        specifier: ^9.0.1
-        version: 9.0.1
       winston:
         specifier: ^3.19.0
         version: 3.19.0
     devDependencies:
       '@oclif/test':
         specifier: ^4.1.18
-        version: 4.1.18(@oclif/core@4.10.5)
+        version: 4.1.18(@oclif/core@4.11.2)
       '@types/big-json':
         specifier: ^3.2.5
         version: 3.2.5
@@ -648,24 +607,15 @@ importers:
       '@types/node':
         specifier: ^14.18.63
         version: 14.18.63
-      '@types/rewire':
-        specifier: ^2.5.30
-        version: 2.5.30
-      '@types/tar':
-        specifier: ^6.1.13
-        version: 6.1.13
-      '@types/uuid':
-        specifier: ^9.0.8
-        version: 9.0.8
       '@typescript-eslint/eslint-plugin':
         specifier: ^5.62.0
-        version: 5.62.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@4.9.5))(eslint@8.57.1)(typescript@4.9.5)
+        version: 5.62.0(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@4.9.5))(eslint@9.39.4)(typescript@4.9.5)
       eslint:
-        specifier: ^8.57.1
-        version: 8.57.1
+        specifier: ^9.26.0
+        version: 9.39.4
       eslint-config-oclif:
         specifier: ^6.0.89
-        version: 6.0.159(eslint@8.57.1)(typescript@4.9.5)
+        version: 6.0.164(eslint@9.39.4)(typescript@4.9.5)
       mocha:
         specifier: ^10.8.2
         version: 10.8.2
@@ -675,9 +625,6 @@ importers:
       oclif:
         specifier: ^4.17.46
         version: 4.23.0(@types/node@14.18.63)
-      rewire:
-        specifier: ^9.0.1
-        version: 9.0.1
       ts-node:
         specifier: ^10.9.2
         version: 10.9.2(@types/node@14.18.63)(typescript@4.9.5)
@@ -695,7 +642,7 @@ importers:
         version: 2.0.0-beta.7(@types/node@14.18.63)(debug@4.4.3)
       '@oclif/core':
         specifier: ^4.3.0
-        version: 4.10.5
+        version: 4.11.2
       big-json:
         specifier: ^3.2.0
         version: 3.2.0
@@ -704,7 +651,7 @@ importers:
         version: 5.6.2
       fs-extra:
         specifier: ^11.3.0
-        version: 11.3.4
+        version: 11.3.5
       lodash:
         specifier: ^4.18.1
         version: 4.18.1
@@ -721,9 +668,6 @@ importers:
       '@types/big-json':
         specifier: ^3.2.5
         version: 3.2.5
-      '@types/bluebird':
-        specifier: ^3.5.42
-        version: 3.5.42
       '@types/chai':
         specifier: ^4.3.20
         version: 4.3.20
@@ -753,16 +697,13 @@ importers:
         version: 9.0.8
       '@typescript-eslint/eslint-plugin':
         specifier: ^5.62.0
-        version: 5.62.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@4.9.5))(eslint@8.57.1)(typescript@4.9.5)
+        version: 5.62.0(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@4.9.5))(eslint@9.39.4)(typescript@4.9.5)
       chai:
         specifier: ^4.5.0
         version: 4.5.0
       eslint:
-        specifier: ^8.57.1
-        version: 8.57.1
-      eslint-config-oclif:
-        specifier: ^6.0.62
-        version: 6.0.159(eslint@8.57.1)(typescript@4.9.5)
+        specifier: ^9.26.0
+        version: 9.39.4
       mocha:
         specifier: ^10.8.2
         version: 10.8.2
@@ -781,9 +722,6 @@ importers:
       ts-node:
         specifier: ^10.9.2
         version: 10.9.2(@types/node@14.18.63)(typescript@4.9.5)
-      tsx:
-        specifier: ^4.20.3
-        version: 4.21.0
       typescript:
         specifier: ^4.9.5
         version: 4.9.5
@@ -798,10 +736,7 @@ importers:
         version: 2.0.0-beta.7(@types/node@14.18.63)(debug@4.4.3)
       '@oclif/core':
         specifier: ^4.3.0
-        version: 4.10.5
-      '@oclif/plugin-help':
-        specifier: ^6.2.28
-        version: 6.2.44
+        version: 4.11.2
       async:
         specifier: ^3.2.6
         version: 3.2.6
@@ -829,7 +764,7 @@ importers:
     devDependencies:
       '@oclif/test':
         specifier: ^4.1.18
-        version: 4.1.18(@oclif/core@4.10.5)
+        version: 4.1.18(@oclif/core@4.11.2)
       '@types/mocha':
         specifier: ^8.2.3
         version: 8.2.3
@@ -840,11 +775,11 @@ importers:
         specifier: ^4.5.0
         version: 4.5.0
       eslint:
-        specifier: ^8.57.1
-        version: 8.57.1
+        specifier: ^9.26.0
+        version: 9.39.4
       eslint-config-oclif:
         specifier: ^6.0.62
-        version: 6.0.159(eslint@8.57.1)(typescript@4.9.5)
+        version: 6.0.164(eslint@9.39.4)(typescript@4.9.5)
       jsdoc-to-markdown:
         specifier: ^8.0.3
         version: 8.0.3
@@ -873,6 +808,118 @@ importers:
         specifier: ^4.9.5
         version: 4.9.5
 
+  packages/contentstack-query-export:
+    dependencies:
+      '@contentstack/cli-cm-export':
+        specifier: ~2.0.0-beta.16
+        version: link:../contentstack-export
+      '@contentstack/cli-command':
+        specifier: ~2.0.0-beta.6
+        version: 2.0.0-beta.6(@types/node@20.19.41)
+      '@contentstack/cli-utilities':
+        specifier: ~2.0.0-beta.7
+        version: 2.0.0-beta.7(@types/node@20.19.41)
+      '@oclif/core':
+        specifier: ^4.10.5
+        version: 4.11.2
+      async:
+        specifier: ^3.2.6
+        version: 3.2.6
+      big-json:
+        specifier: ^3.2.0
+        version: 3.2.0
+      bluebird:
+        specifier: ^3.7.2
+        version: 3.7.2
+      lodash:
+        specifier: ^4.18.1
+        version: 4.18.1
+      merge:
+        specifier: ^2.1.1
+        version: 2.1.1
+      mkdirp:
+        specifier: ^1.0.4
+        version: 1.0.4
+      progress-stream:
+        specifier: ^2.0.0
+        version: 2.0.0
+      promise-limit:
+        specifier: ^2.7.0
+        version: 2.7.0
+      tslib:
+        specifier: ^2.8.1
+        version: 2.8.1
+      winston:
+        specifier: ^3.19.0
+        version: 3.19.0
+    devDependencies:
+      '@contentstack/cli-dev-dependencies':
+        specifier: ~1.3.1
+        version: 1.3.1
+      '@oclif/plugin-help':
+        specifier: ^6.2.44
+        version: 6.2.48
+      '@oclif/test':
+        specifier: ^4.1.18
+        version: 4.1.18(@oclif/core@4.11.2)
+      '@types/big-json':
+        specifier: ^3.2.5
+        version: 3.2.5
+      '@types/chai':
+        specifier: ^4.3.20
+        version: 4.3.20
+      '@types/mkdirp':
+        specifier: ^1.0.2
+        version: 1.0.2
+      '@types/mocha':
+        specifier: ^10.0.10
+        version: 10.0.10
+      '@types/node':
+        specifier: ^20.19.39
+        version: 20.19.41
+      '@types/progress-stream':
+        specifier: ^2.0.5
+        version: 2.0.5
+      '@types/sinon':
+        specifier: ^17.0.4
+        version: 17.0.4
+      chai:
+        specifier: ^4.5.0
+        version: 4.5.0
+      dotenv:
+        specifier: ^16.6.1
+        version: 16.6.1
+      dotenv-expand:
+        specifier: ^9.0.0
+        version: 9.0.0
+      eslint:
+        specifier: ^8.57.1
+        version: 8.57.1
+      eslint-config-oclif:
+        specifier: ^6.0.157
+        version: 6.0.164(eslint@8.57.1)(typescript@4.9.5)
+      husky:
+        specifier: ^9.1.7
+        version: 9.1.7
+      mocha:
+        specifier: 10.8.2
+        version: 10.8.2
+      nyc:
+        specifier: ^15.1.0
+        version: 15.1.0
+      oclif:
+        specifier: ^4.17.46
+        version: 4.23.0(@types/node@20.19.41)
+      sinon:
+        specifier: ^17.0.2
+        version: 17.0.2
+      ts-node:
+        specifier: ^10.9.2
+        version: 10.9.2(@types/node@20.19.41)(typescript@4.9.5)
+      typescript:
+        specifier: ^4.9.5
+        version: 4.9.5
+
   packages/contentstack-seed:
     dependencies:
       '@contentstack/cli-cm-import':
@@ -892,14 +939,14 @@ importers:
         version: 1.0.4
       tar:
         specifier: ^7.5.11
-        version: 7.5.13
+        version: 7.5.15
       tmp:
         specifier: 0.2.4
         version: 0.2.4
     devDependencies:
       '@oclif/plugin-help':
         specifier: ^6.2.28
-        version: 6.2.44
+        version: 6.2.48
       '@types/inquirer':
         specifier: ^9.0.9
         version: 9.0.9
@@ -918,18 +965,15 @@ importers:
       '@types/tmp':
         specifier: ^0.2.6
         version: 0.2.6
-      axios:
-        specifier: 1.15.2
-        version: 1.15.2(debug@4.4.3)
       eslint:
-        specifier: ^8.57.1
-        version: 8.57.1
+        specifier: ^9.26.0
+        version: 9.39.4
       eslint-config-oclif:
         specifier: ^6.0.137
-        version: 6.0.159(eslint@8.57.1)(typescript@5.9.3)
+        version: 6.0.164(eslint@9.39.4)(typescript@5.9.3)
       eslint-config-oclif-typescript:
         specifier: ^3.1.14
-        version: 3.1.14(eslint@8.57.1)(typescript@5.9.3)
+        version: 3.1.14(eslint@9.39.4)(typescript@5.9.3)
       jest:
         specifier: ^29.7.0
         version: 29.7.0(@types/node@18.19.130)(ts-node@8.10.2(typescript@5.9.3))
@@ -950,13 +994,10 @@ importers:
     dependencies:
       '@contentstack/cli-utilities':
         specifier: ~2.0.0-beta.7
-        version: 2.0.0-beta.7(@types/node@20.19.39)
+        version: 2.0.0-beta.7(@types/node@20.19.41)
       '@oclif/core':
         specifier: ^4.3.0
-        version: 4.10.5
-      '@oclif/plugin-help':
-        specifier: ^6.2.28
-        version: 6.2.44
+        version: 4.11.2
       lodash:
         specifier: ^4.18.1
         version: 4.18.1
@@ -972,10 +1013,10 @@ importers:
         version: 2.0.0-beta.0
       '@oclif/test':
         specifier: ^4.1.18
-        version: 4.1.18(@oclif/core@4.10.5)
+        version: 4.1.18(@oclif/core@4.11.2)
       '@types/node':
         specifier: ^20.19.39
-        version: 20.19.39
+        version: 20.19.41
       mocha:
         specifier: ^10.8.2
         version: 10.8.2
@@ -984,7 +1025,7 @@ importers:
         version: 15.1.0
       ts-node:
         specifier: ^10.9.2
-        version: 10.9.2(@types/node@20.19.39)(typescript@5.9.3)
+        version: 10.9.2(@types/node@20.19.41)(typescript@5.9.3)
       typescript:
         specifier: ^5.8.3
         version: 5.9.3
@@ -1022,44 +1063,44 @@ packages:
     resolution: {integrity: sha512-0XLrOT4Cm3NEhhiME7l/8LbTXS4KdsbR4dSrY207KNKTcHLLTZ9EXt4ZpgnTfLvWQF3pGP2us4Zi1fYLo0N+Ow==}
     engines: {node: '>=20.0.0'}
 
-  '@aws-sdk/core@3.974.3':
-    resolution: {integrity: sha512-W3aJJm2clu8OmsrwMOMnfof13O6LGnbknnZIQeSRbxjqKah2nVvkjbUBBZVhWrt08KC69H7WsINTdrxC/2SXQw==}
+  '@aws-sdk/core@3.974.8':
+    resolution: {integrity: sha512-njR2qoG6ZuB0kvAS2FyICsFZJ6gmCcf2X/7JcD14sUvGDm26wiZ5BrA6LOiUxKFEF+IVe7kdroxyE00YlkiYsw==}
     engines: {node: '>=20.0.0'}
 
   '@aws-sdk/crc64-nvme@3.972.7':
     resolution: {integrity: sha512-QUagVVBbC8gODCF6e1aV0mE2TXWB9Opz4k8EJFdNrujUVQm5R4AjJa1mpOqzwOuROBzqJU9zawzig7M96L8Ejg==}
     engines: {node: '>=20.0.0'}
 
-  '@aws-sdk/credential-provider-env@3.972.29':
-    resolution: {integrity: sha512-rf+AlUxgTeSzQ/4zoS0D+Bt7XvgpY48PnWG8Yg/N9fdMgyK2Jaqa+6tLZp4MYMIMHkGrfAxnbSeb2YLMGFMg6g==}
+  '@aws-sdk/credential-provider-env@3.972.34':
+    resolution: {integrity: sha512-XT0jtf8Fw9JE6ppsQeoNnZRiG+jqRixMT1v1ZR17G60UvVdsQmTG8nbEyHuEPfMxDXEhfdARaM/XiEhca4lGHQ==}
     engines: {node: '>=20.0.0'}
 
-  '@aws-sdk/credential-provider-http@3.972.31':
-    resolution: {integrity: sha512-TR2/lQ3qKFj2EOrsiASzemsNEz2uzZ/SUBf48+U4Cr9a/FZlHfH/hwAeBJNBp1gMyJNxROJZhT3dn1cO+jnYfQ==}
+  '@aws-sdk/credential-provider-http@3.972.36':
+    resolution: {integrity: sha512-DPoGWfy7J7RKxvbf5kOKIGQkD2ek3dbKgzKIGrnLuvZBz5myU+Im/H6pmc14QcnFbqHMqxvtWSgRDSJW3qXLQg==}
     engines: {node: '>=20.0.0'}
 
-  '@aws-sdk/credential-provider-ini@3.972.33':
-    resolution: {integrity: sha512-UwdbJbOrgnOxZbshaNZ4DzX35h5wQd33MNYTGzWhN3ORG9lG9KQbDX6l6tDJSAdaGTktJoZPSritmUoW1rYkRA==}
+  '@aws-sdk/credential-provider-ini@3.972.38':
+    resolution: {integrity: sha512-oDzUBu2MGJFgoar05sPMCwSrhw44ASyccrHzj66vO69OZqi7I6hZZxXfuPLC8OCzW7C+sU+bI73XHij41yekgQ==}
     engines: {node: '>=20.0.0'}
 
-  '@aws-sdk/credential-provider-login@3.972.33':
-    resolution: {integrity: sha512-WyZuPVoDM1HGNl41eVg8HSSXIB+FGkuuK63GhDbh4TMdfWU03AciWvF/QqOVWvJtWVYaLddANJ+aUklVr2ieuw==}
+  '@aws-sdk/credential-provider-login@3.972.38':
+    resolution: {integrity: sha512-g1NosS8qe4OF++G2UFCM5ovSkgipC7YYor5KCWatG0UoMSO5YFj9C8muePlyVmOBV/WTI16Jo3/s1NUo/o1Bww==}
     engines: {node: '>=20.0.0'}
 
-  '@aws-sdk/credential-provider-node@3.972.34':
-    resolution: {integrity: sha512-sPcisURibKU4x0PCWJkWF1KJYm49Cph9dCn/PAnG5FU0wq5Id3g2v7RuEWAtNlKv1Af4gUJYBVGOeNpSEEx41A==}
+  '@aws-sdk/credential-provider-node@3.972.39':
+    resolution: {integrity: sha512-HEswDQyxUtadoZ/bJsPPENHg7R0Lzym5LuMksJeHvqhCOpP+rtkDLKI4/ZChH4w3cf5kG8n6bZuI8PzajoiqMg==}
     engines: {node: '>=20.0.0'}
 
-  '@aws-sdk/credential-provider-process@3.972.29':
-    resolution: {integrity: sha512-DURisqWS3bUgiwMXTmzymVNGlcRW0FnbPZ3SZknhmxnCXm3n9idkTJ6T+Uir359KRKtJNFLRViskk8HsSVLi1w==}
+  '@aws-sdk/credential-provider-process@3.972.34':
+    resolution: {integrity: sha512-T3IFs4EVmVi1dVN5RciFnklCANSzvrQd/VuHY9ThHSQmYkTogjcGkoJEr+oNUPQZnso52183088NqysMPji1/Q==}
     engines: {node: '>=20.0.0'}
 
-  '@aws-sdk/credential-provider-sso@3.972.33':
-    resolution: {integrity: sha512-9y9obU4IQWru9f+NiiscUeyCe5ZmQav4FKEb1qfUNrik/C3BzBGUnHQWyPEyXjOX9cb+vx1TYx0qZBtinKdzTA==}
+  '@aws-sdk/credential-provider-sso@3.972.38':
+    resolution: {integrity: sha512-5ZxG+t0+3Q3QPh8KEjX6syskhgNf7I0MN7oGioTf6Lm1NTjfP7sIcYGNsthXC2qR8vcD3edNZwCr2ovfSSWuRA==}
     engines: {node: '>=20.0.0'}
 
-  '@aws-sdk/credential-provider-web-identity@3.972.33':
-    resolution: {integrity: sha512-RazhlN0YAkna2T2p2v4YuuRlVBVRNo8V0SL+9JePTWDndEUAeOBAjYeQfAMbtDyCh120+zA0Op6V0jS4dw2+iw==}
+  '@aws-sdk/credential-provider-web-identity@3.972.38':
+    resolution: {integrity: sha512-lYHFF30DGI20jZcYX8cm6Ns0V7f1dDN6g/MBDLTyD/5iw+bXs3yBr2iAiHDkx4RFU5JgsnZvCHYKiRVPRdmOgw==}
     engines: {node: '>=20.0.0'}
 
   '@aws-sdk/middleware-bucket-endpoint@3.972.10':
@@ -1070,8 +1111,8 @@ packages:
     resolution: {integrity: sha512-2Yn0f1Qiq/DjxYR3wfI3LokXnjOhFM7Ssn4LTdFDIxRMCE6I32MAsVnhPX1cUZsuVA9tiZtwwhlSLAtFGxAZlQ==}
     engines: {node: '>=20.0.0'}
 
-  '@aws-sdk/middleware-flexible-checksums@3.974.11':
-    resolution: {integrity: sha512-jTrJFs4SMs9xjih45+QHtU79piovA6CAlofMt4jeknN5ef9zsVEHDtuwCnEe/3eANWewa9fd6Tvc54xEPpQ3RA==}
+  '@aws-sdk/middleware-flexible-checksums@3.974.16':
+    resolution: {integrity: sha512-6ru8doI0/XzszqLIPXf0E/V7HhAw1Pu94010XCKYtBUfD0LxF0BuOzrUf8OQGR6j2o6wgKTHUniOmndQycHwCA==}
     engines: {node: '>=20.0.0'}
 
   '@aws-sdk/middleware-host-header@3.972.10':
@@ -1090,32 +1131,32 @@ packages:
     resolution: {integrity: sha512-+zz6f79Kj9V5qFK2P+D8Ehjnw4AhphAlCAsPjUqEcInA9umtSSKMrHbSagEeOIsDNuvVrH98bjRHcyQukTrhaQ==}
     engines: {node: '>=20.0.0'}
 
-  '@aws-sdk/middleware-sdk-s3@3.972.32':
-    resolution: {integrity: sha512-dc2O2x0V5pGJhmdQYQveUIFtMZsur7GrGuSgoKM4oQJuEcfvwnJ3sj+ip6WnxR5l6TrX5zkl4KgcgswOy3wAzQ==}
+  '@aws-sdk/middleware-sdk-s3@3.972.37':
+    resolution: {integrity: sha512-Km7M+i8DrLArVzrid1gfxeGhYHBd3uxvE77g0s5a52zPSVosxzQBnJ0gwWb6NIp/DOk8gsBMhi7V+cpJG0ndTA==}
     engines: {node: '>=20.0.0'}
 
   '@aws-sdk/middleware-ssec@3.972.10':
     resolution: {integrity: sha512-Gli9A0u8EVVb+5bFDGS/QbSVg28w/wpEidg1ggVcSj65BDTdGR6punsOcVjqdiu1i42WHWo51MCvARPIIz9juw==}
     engines: {node: '>=20.0.0'}
 
-  '@aws-sdk/middleware-user-agent@3.972.33':
-    resolution: {integrity: sha512-mqtT3Fo7xanWMk2SbAcKLGGI/q1GHWNrExBj7cnWP2W2mkTMheXB4ntJvwPZ1UxPrQobrsv2dWFXmaOJeSOiDg==}
+  '@aws-sdk/middleware-user-agent@3.972.38':
+    resolution: {integrity: sha512-iz+B29TXcAZsJpwB+AwG/TTGA5l/VnmMZ2UxtiySOZjI6gCdmviXPwdgzcmuazMy16rXoPY4mYCGe7zdNKfx5A==}
     engines: {node: '>=20.0.0'}
 
-  '@aws-sdk/nested-clients@3.997.1':
-    resolution: {integrity: sha512-Afc9hc2WZs3X4Jb8dnxyuYiZsLoWRO51roTCRf497gPnAKN2WRdXANu1vaVCTzwnDMOYFXb/cYv4ZSjxqAqcKA==}
+  '@aws-sdk/nested-clients@3.997.6':
+    resolution: {integrity: sha512-WBDnqatJl+kGObpfmfSxqnXeYTu3Me8wx8WCtvoxX3pfWrrTv8I4WTMSSs7PZqcRcVh8WeUKMgGFjMG+52SR1w==}
     engines: {node: '>=20.0.0'}
 
   '@aws-sdk/region-config-resolver@3.972.13':
     resolution: {integrity: sha512-CvJ2ZIjK/jVD/lbOpowBVElJyC1YxLTIJ13yM0AEo0t2v7swOzGjSA6lJGH+DwZXQhcjUjoYwc8bVYCX5MDr1A==}
     engines: {node: '>=20.0.0'}
 
-  '@aws-sdk/signature-v4-multi-region@3.996.20':
-    resolution: {integrity: sha512-MEj6DhEcaO8RgVtFCJ+xpCQnZC3Iesr09avdY75qkMQfckQULu447IegK7Rs1MCGerVBfKnJQ4q+pQq9hI5lng==}
+  '@aws-sdk/signature-v4-multi-region@3.996.25':
+    resolution: {integrity: sha512-+CMIt3e1VzlklAECmG+DtP1sV8iKq25FuA0OKpnJ4KA0kxUtd7CgClY7/RU6VzJBQwbN4EJ9Ue6plvqx1qGadw==}
     engines: {node: '>=20.0.0'}
 
-  '@aws-sdk/token-providers@3.1034.0':
-    resolution: {integrity: sha512-8E+KGcD4ET0H9FXJ2/ZWbfFnQNYEkTZZYJxAs1lkdJlve1AYuqaydInIFfvNgoz5GbYtzbK8/ugsSMu5wPm6kA==}
+  '@aws-sdk/token-providers@3.1041.0':
+    resolution: {integrity: sha512-Th7kPI6YPtvJUcdznooXJMy+9rQWjmEF81LxaJssngBzuysK4a/x+l8kjm1zb7nYsUPbndnBdUnwng/3PLvtGw==}
     engines: {node: '>=20.0.0'}
 
   '@aws-sdk/types@3.973.8':
@@ -1137,8 +1178,8 @@ packages:
   '@aws-sdk/util-user-agent-browser@3.972.10':
     resolution: {integrity: sha512-FAzqXvfEssGdSIz8ejatan0bOdx1qefBWKF/gWmVBXIP1HkS7v/wjjaqrAGGKvyihrXTXW00/2/1nTJtxpXz7g==}
 
-  '@aws-sdk/util-user-agent-node@3.973.19':
-    resolution: {integrity: sha512-ZAfHjpzdbrzkAftC139JoYGfXzDh5HY+AxRzw8pGJ8cULsf+l721sKAMK8mV5NvRETaW/BwghSwQhGgoNgrxMw==}
+  '@aws-sdk/util-user-agent-node@3.973.24':
+    resolution: {integrity: sha512-ZWwlkjcIp7cEL8ZfTpTAPNkwx25p7xol0xlKoWVVf22+nsjwmLcHYtTPjIV1cSpmB/b6DaK4cb1fSkvCXHgRdw==}
     engines: {node: '>=20.0.0'}
     peerDependencies:
       aws-crt: '>=1.0.0'
@@ -1146,8 +1187,8 @@ packages:
       aws-crt:
         optional: true
 
-  '@aws-sdk/xml-builder@3.972.18':
-    resolution: {integrity: sha512-BMDNVG1ETXRhl1tnisQiYBef3RShJ1kfZA7x7afivTFMLirfHNTb6U71K569HNXhSXbQZsweHvSDZ6euBw8hPA==}
+  '@aws-sdk/xml-builder@3.972.22':
+    resolution: {integrity: sha512-PMYKKtJd70IsSG0yHrdAbxBr+ZWBKLvzFZfD3/urxgf6hXVMzuU5M+3MJ5G67RpOmLBu1fAUN65SbWuKUCOlAA==}
     engines: {node: '>=20.0.0'}
 
   '@aws/lambda-invoke-store@0.2.4':
@@ -1158,8 +1199,8 @@ packages:
     resolution: {integrity: sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/compat-data@7.29.0':
-    resolution: {integrity: sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==}
+  '@babel/compat-data@7.29.3':
+    resolution: {integrity: sha512-LIVqM46zQWZhj17qA8wb4nW/ixr2y1Nw+r1etiAWgRM6U1IqP+LNhL1yg440jYZR72jCWcWbLWzIosH+uP1fqg==}
     engines: {node: '>=6.9.0'}
 
   '@babel/core@7.29.0':
@@ -1208,8 +1249,8 @@ packages:
     resolution: {integrity: sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/parser@7.29.2':
-    resolution: {integrity: sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==}
+  '@babel/parser@7.29.3':
+    resolution: {integrity: sha512-b3ctpQwp+PROvU/cttc4OYl4MzfJUWy6FZg+PMXfzmt/+39iHVF0sDfqay8TQM3JA2EUOyKcFZt75jWriQijsA==}
     engines: {node: '>=6.0.0'}
     hasBin: true
 
@@ -1339,18 +1380,21 @@ packages:
     resolution: {integrity: sha512-60Xg/D9PhRDwoeP8vtt8oljRAQW+/I16/QNF6AwxhEzNHiB0pahrNzSX/7ESTJR6574ipNH0ssc8kSB6Zs8WAg==}
     engines: {node: '>=14.0.0'}
 
+  '@contentstack/cli-dev-dependencies@1.3.1':
+    resolution: {integrity: sha512-RQuCGQxBdZ+aNhOMwt/VMpz/9AL2PwIFz7H9rUS6BzPOe6G4RjmzFLXi/gnyECbyLoIgyGGXTjlz8NQ0oapp7Q==}
+
   '@contentstack/cli-dev-dependencies@2.0.0-beta.0':
     resolution: {integrity: sha512-tLP05taIeepvp5Xte2LKDTKeYtDjCxOLlNWzwMFhMFYU1Z7oOgiCu8RVHNz+EkAm5xScKORx1OyEgyNLFoTLBw==}
 
   '@contentstack/cli-utilities@2.0.0-beta.7':
     resolution: {integrity: sha512-V0ooac32Krs5j+yS5mccGGjg+3blTt1P3xuqM0LlPfTmX3JWnQYgFZEBYE4yr4GHTFAIqog5xM5zQKjyM/KMpA==}
 
-  '@contentstack/management@1.30.1':
-    resolution: {integrity: sha512-rwceQJ78/yRORDwlq+vO5ge5C02YIfiHvCPxpJXA/UJwHTuwehkMH6wQzFdBHnWItQU+ymT4oN9lX1uA31V52A==}
+  '@contentstack/management@1.30.2':
+    resolution: {integrity: sha512-DPr/4N35dbclU/PAugB3PGom5MSxYOqicIgP7TPnOlO6TY7r76VIPiycu8yXck71RH+Dmeni1+cMwMlIfzrYOQ==}
     engines: {node: '>=8.0.0'}
 
-  '@contentstack/marketplace-sdk@1.5.1':
-    resolution: {integrity: sha512-XoQODTWZ4cQeo7iIAcYcYLX9bSHvgeF1J230GTM2dVhN3w9aTylZ35zZttvsa76fDZWgRmZBO5AE99dVVq7xyA==}
+  '@contentstack/marketplace-sdk@1.5.2':
+    resolution: {integrity: sha512-BAjHLuAkKw+tcF/nE6UrD5QzIm+xFQrk/2vnWajJF3XJ9W/Ovg/5H9BLMpD+AfkwoRaWh8vAqLdt4nVQyr5e+g==}
 
   '@contentstack/utils@1.9.1':
     resolution: {integrity: sha512-THZM0rNuq0uOSKkKnvzp8lsPDvvdKIvJIcMa9JBv4foL9rC8RWkWffa2yMyb+9m/5HZrdAmpEWdubkGwARa8WQ==}
@@ -1375,162 +1419,6 @@ packages:
     resolution: {integrity: sha512-YAdE/IJSpwbOTiaURNCKECdAwqrJuFiZhylmesBcIRawtYKnBR2wxPhoIewMg+Yu+QuYvHfJNReWpoxGBKOChA==}
     engines: {node: '>=18'}
 
-  '@esbuild/aix-ppc64@0.27.7':
-    resolution: {integrity: sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg==}
-    engines: {node: '>=18'}
-    cpu: [ppc64]
-    os: [aix]
-
-  '@esbuild/android-arm64@0.27.7':
-    resolution: {integrity: sha512-62dPZHpIXzvChfvfLJow3q5dDtiNMkwiRzPylSCfriLvZeq0a1bWChrGx/BbUbPwOrsWKMn8idSllklzBy+dgQ==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [android]
-
-  '@esbuild/android-arm@0.27.7':
-    resolution: {integrity: sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ==}
-    engines: {node: '>=18'}
-    cpu: [arm]
-    os: [android]
-
-  '@esbuild/android-x64@0.27.7':
-    resolution: {integrity: sha512-x5VpMODneVDb70PYV2VQOmIUUiBtY3D3mPBG8NxVk5CogneYhkR7MmM3yR/uMdITLrC1ml/NV1rj4bMJuy9MCg==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [android]
-
-  '@esbuild/darwin-arm64@0.27.7':
-    resolution: {integrity: sha512-5lckdqeuBPlKUwvoCXIgI2D9/ABmPq3Rdp7IfL70393YgaASt7tbju3Ac+ePVi3KDH6N2RqePfHnXkaDtY9fkw==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@esbuild/darwin-x64@0.27.7':
-    resolution: {integrity: sha512-rYnXrKcXuT7Z+WL5K980jVFdvVKhCHhUwid+dDYQpH+qu+TefcomiMAJpIiC2EM3Rjtq0sO3StMV/+3w3MyyqQ==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [darwin]
-
-  '@esbuild/freebsd-arm64@0.27.7':
-    resolution: {integrity: sha512-B48PqeCsEgOtzME2GbNM2roU29AMTuOIN91dsMO30t+Ydis3z/3Ngoj5hhnsOSSwNzS+6JppqWsuhTp6E82l2w==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [freebsd]
-
-  '@esbuild/freebsd-x64@0.27.7':
-    resolution: {integrity: sha512-jOBDK5XEjA4m5IJK3bpAQF9/Lelu/Z9ZcdhTRLf4cajlB+8VEhFFRjWgfy3M1O4rO2GQ/b2dLwCUGpiF/eATNQ==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [freebsd]
-
-  '@esbuild/linux-arm64@0.27.7':
-    resolution: {integrity: sha512-RZPHBoxXuNnPQO9rvjh5jdkRmVizktkT7TCDkDmQ0W2SwHInKCAV95GRuvdSvA7w4VMwfCjUiPwDi0ZO6Nfe9A==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [linux]
-
-  '@esbuild/linux-arm@0.27.7':
-    resolution: {integrity: sha512-RkT/YXYBTSULo3+af8Ib0ykH8u2MBh57o7q/DAs3lTJlyVQkgQvlrPTnjIzzRPQyavxtPtfg0EopvDyIt0j1rA==}
-    engines: {node: '>=18'}
-    cpu: [arm]
-    os: [linux]
-
-  '@esbuild/linux-ia32@0.27.7':
-    resolution: {integrity: sha512-GA48aKNkyQDbd3KtkplYWT102C5sn/EZTY4XROkxONgruHPU72l+gW+FfF8tf2cFjeHaRbWpOYa/uRBz/Xq1Pg==}
-    engines: {node: '>=18'}
-    cpu: [ia32]
-    os: [linux]
-
-  '@esbuild/linux-loong64@0.27.7':
-    resolution: {integrity: sha512-a4POruNM2oWsD4WKvBSEKGIiWQF8fZOAsycHOt6JBpZ+JN2n2JH9WAv56SOyu9X5IqAjqSIPTaJkqN8F7XOQ5Q==}
-    engines: {node: '>=18'}
-    cpu: [loong64]
-    os: [linux]
-
-  '@esbuild/linux-mips64el@0.27.7':
-    resolution: {integrity: sha512-KabT5I6StirGfIz0FMgl1I+R1H73Gp0ofL9A3nG3i/cYFJzKHhouBV5VWK1CSgKvVaG4q1RNpCTR2LuTVB3fIw==}
-    engines: {node: '>=18'}
-    cpu: [mips64el]
-    os: [linux]
-
-  '@esbuild/linux-ppc64@0.27.7':
-    resolution: {integrity: sha512-gRsL4x6wsGHGRqhtI+ifpN/vpOFTQtnbsupUF5R5YTAg+y/lKelYR1hXbnBdzDjGbMYjVJLJTd2OFmMewAgwlQ==}
-    engines: {node: '>=18'}
-    cpu: [ppc64]
-    os: [linux]
-
-  '@esbuild/linux-riscv64@0.27.7':
-    resolution: {integrity: sha512-hL25LbxO1QOngGzu2U5xeXtxXcW+/GvMN3ejANqXkxZ/opySAZMrc+9LY/WyjAan41unrR3YrmtTsUpwT66InQ==}
-    engines: {node: '>=18'}
-    cpu: [riscv64]
-    os: [linux]
-
-  '@esbuild/linux-s390x@0.27.7':
-    resolution: {integrity: sha512-2k8go8Ycu1Kb46vEelhu1vqEP+UeRVj2zY1pSuPdgvbd5ykAw82Lrro28vXUrRmzEsUV0NzCf54yARIK8r0fdw==}
-    engines: {node: '>=18'}
-    cpu: [s390x]
-    os: [linux]
-
-  '@esbuild/linux-x64@0.27.7':
-    resolution: {integrity: sha512-hzznmADPt+OmsYzw1EE33ccA+HPdIqiCRq7cQeL1Jlq2gb1+OyWBkMCrYGBJ+sxVzve2ZJEVeePbLM2iEIZSxA==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [linux]
-
-  '@esbuild/netbsd-arm64@0.27.7':
-    resolution: {integrity: sha512-b6pqtrQdigZBwZxAn1UpazEisvwaIDvdbMbmrly7cDTMFnw/+3lVxxCTGOrkPVnsYIosJJXAsILG9XcQS+Yu6w==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [netbsd]
-
-  '@esbuild/netbsd-x64@0.27.7':
-    resolution: {integrity: sha512-OfatkLojr6U+WN5EDYuoQhtM+1xco+/6FSzJJnuWiUw5eVcicbyK3dq5EeV/QHT1uy6GoDhGbFpprUiHUYggrw==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [netbsd]
-
-  '@esbuild/openbsd-arm64@0.27.7':
-    resolution: {integrity: sha512-AFuojMQTxAz75Fo8idVcqoQWEHIXFRbOc1TrVcFSgCZtQfSdc1RXgB3tjOn/krRHENUB4j00bfGjyl2mJrU37A==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [openbsd]
-
-  '@esbuild/openbsd-x64@0.27.7':
-    resolution: {integrity: sha512-+A1NJmfM8WNDv5CLVQYJ5PshuRm/4cI6WMZRg1by1GwPIQPCTs1GLEUHwiiQGT5zDdyLiRM/l1G0Pv54gvtKIg==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [openbsd]
-
-  '@esbuild/openharmony-arm64@0.27.7':
-    resolution: {integrity: sha512-+KrvYb/C8zA9CU/g0sR6w2RBw7IGc5J2BPnc3dYc5VJxHCSF1yNMxTV5LQ7GuKteQXZtspjFbiuW5/dOj7H4Yw==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [openharmony]
-
-  '@esbuild/sunos-x64@0.27.7':
-    resolution: {integrity: sha512-ikktIhFBzQNt/QDyOL580ti9+5mL/YZeUPKU2ivGtGjdTYoqz6jObj6nOMfhASpS4GU4Q/Clh1QtxWAvcYKamA==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [sunos]
-
-  '@esbuild/win32-arm64@0.27.7':
-    resolution: {integrity: sha512-7yRhbHvPqSpRUV7Q20VuDwbjW5kIMwTHpptuUzV+AA46kiPze5Z7qgt6CLCK3pWFrHeNfDd1VKgyP4O+ng17CA==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [win32]
-
-  '@esbuild/win32-ia32@0.27.7':
-    resolution: {integrity: sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw==}
-    engines: {node: '>=18'}
-    cpu: [ia32]
-    os: [win32]
-
-  '@esbuild/win32-x64@0.27.7':
-    resolution: {integrity: sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [win32]
-
   '@eslint-community/eslint-utils@4.9.1':
     resolution: {integrity: sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -1915,6 +1803,9 @@ packages:
   '@napi-rs/wasm-runtime@0.2.12':
     resolution: {integrity: sha512-ZVWUcfwY4E/yPitQJl481FjFo3K22D6qF0DuFH6Y/nbnE11GY5uguDxZMGXPQ8WQ0128MXQD7TnfHyK4oWoIJQ==}
 
+  '@nodable/entities@2.1.0':
+    resolution: {integrity: sha512-nyT7T3nbMyBI/lvr6L5TyWbFJAI9FTgVRakNoBqCD+PmID8DzFrrNdLLtHMwMszOtqZa8PAOV24ZqDnQrhQINA==}
+
   '@nodelib/fs.scandir@2.1.5':
     resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
     engines: {node: '>= 8'}
@@ -1931,24 +1822,24 @@ packages:
     resolution: {integrity: sha512-nn5ozdjYQpUCZlWGuxcJY/KpxkWQs4DcbMCmKojjyrYDEAGy4Ce19NN4v5MduafTwJlbKc99UA8YhSVqq9yPZA==}
     engines: {node: '>=12.4.0'}
 
-  '@oclif/core@4.10.5':
-    resolution: {integrity: sha512-qcdCF7NrdWPfme6Kr34wwljRCXbCVpL1WVxiNy0Ep6vbWKjxAjFQwuhqkoyL0yjI+KdwtLcOCGn5z2yzdijc8w==}
+  '@oclif/core@4.11.2':
+    resolution: {integrity: sha512-LWDalCgy+hYyAkLa9sMIXMXk6ws5RzQhVnkmfXtVIIyEEYigbXQ/9/x+s76p53MiXxNc6SJB7lfwkPF+SdzfMQ==}
     engines: {node: '>=18.0.0'}
 
   '@oclif/core@4.9.0':
     resolution: {integrity: sha512-k/ntRgDcUprTT+aaNoF+whk3cY3f9fRD2lkF6ul7JeCUg2MaMXVXZXfbRhJCfsiX51X8/5Pqo0LGdO9SLYXNHg==}
     engines: {node: '>=18.0.0'}
 
-  '@oclif/plugin-help@6.2.44':
-    resolution: {integrity: sha512-x03Se2LtlOOlGfTuuubt5C4Z8NHeR4zKXtVnfycuLU+2VOMu2WpsGy9nbs3nYuInuvsIY1BizjVaTjUz060Sig==}
+  '@oclif/plugin-help@6.2.48':
+    resolution: {integrity: sha512-nvGLBtUZUWrHfoAEDRsRZUHKVwptyZ6F+MErdVRLQBo3dja0GCZH8DE33dA7mBux2KOmbxGqop15gyud9HZYhQ==}
     engines: {node: '>=18.0.0'}
 
-  '@oclif/plugin-not-found@3.2.80':
-    resolution: {integrity: sha512-yTLjWvR1r/Rd/cO2LxHdMCDoL5sQhBYRUcOMCmxZtWVWhx4rAZ8KVUPDVsb+SvjJDV5ADTDBgt1H52fFx7YWqg==}
+  '@oclif/plugin-not-found@3.2.85':
+    resolution: {integrity: sha512-Si18rRKWknlvQ5anmFbQz9oKBae5/l/Npreuf05xdoNWfOV1J97Z7cpzqBlHbldmxCIiDRgmDKuCBBi4XN6ACA==}
     engines: {node: '>=18.0.0'}
 
-  '@oclif/plugin-warn-if-update-available@3.1.60':
-    resolution: {integrity: sha512-cRKBZm14IuA6G8W84dfd3iXj3BTAoxQ5o3pUE8DKEQ4n/tVha20t5nkVeD+ISC68e0Fuw5koTMvRwXb1lJSnzg==}
+  '@oclif/plugin-warn-if-update-available@3.1.64':
+    resolution: {integrity: sha512-+BauVC7jeMRs6NPvFFO1KHdSIVL10ruz6W3laKdN0i7PjSo14clmQe+DUJVTADI5Z3eYFYnsISwdDbOU/2pnYQ==}
     engines: {node: '>=18.0.0'}
 
   '@oclif/test@4.1.18':
@@ -2022,8 +1913,8 @@ packages:
   '@sinonjs/fake-timers@11.3.1':
     resolution: {integrity: sha512-EVJO7nW5M/F5Tur0Rf2z/QoMo+1Ia963RiMtapiQrEWvY0iBUvADo8Beegwjpnle5BHkyHuoxSTW3jF43H1XRA==}
 
-  '@sinonjs/fake-timers@15.3.2':
-    resolution: {integrity: sha512-mrn35Jl2pCpns+mE3HaZa1yPN5EYCRgiMI+135COjr2hr8Cls9DXqIZ57vZe2cz7y2XVSq92tcs6kGQcT1J8Rw==}
+  '@sinonjs/fake-timers@15.4.0':
+    resolution: {integrity: sha512-DsG+8/LscQIQg68J6Ef3dv10u6nVyetYn923s3/sus5eaGfTo1of5WMZSLf0UJc9KDuKPilPH0UDJCjvNbDNCA==}
 
   '@sinonjs/samsam@10.0.2':
     resolution: {integrity: sha512-8lVwD1Df1BmzoaOLhMcGGcz/Jyr5QY2KSB75/YK1QgKzoabTeLdIVyhXNZK9ojfSKSdirbXqdbsXXqP9/Ve8+A==}
@@ -2037,216 +1928,172 @@ packages:
       Deprecated: no longer maintained and no longer used by Sinon packages. See
         https://github.com/sinonjs/nise/issues/243 for replacement details.
 
-  '@smithy/chunked-blob-reader-native@4.2.3':
-    resolution: {integrity: sha512-jA5k5Udn7Y5717L86h4EIv06wIr3xn8GM1qHRi/Nf31annXcXHJjBKvgztnbn2TxH3xWrPBfgwHsOwZf0UmQWw==}
-    engines: {node: '>=18.0.0'}
-
-  '@smithy/chunked-blob-reader@5.2.2':
-    resolution: {integrity: sha512-St+kVicSyayWQca+I1rGitaOEH6uKgE8IUWoYnnEX26SWdWQcL6LvMSD19Lg+vYHKdT9B2Zuu7rd3i6Wnyb/iw==}
-    engines: {node: '>=18.0.0'}
-
-  '@smithy/config-resolver@4.4.17':
-    resolution: {integrity: sha512-TzDZcAnhTyAHbXVxWZo7/tEcrIeFq20IBk8So3OLOetWpR8EwY/yEqBMBFaJMeyEiREDq4NfEl+qO3OAUD+vbQ==}
-    engines: {node: '>=18.0.0'}
-
-  '@smithy/core@3.23.16':
-    resolution: {integrity: sha512-JStomOrINQA1VqNEopLsgcdgwd42au7mykKqVr30XFw89wLt9sDxJDi4djVPRwQmmzyTGy/uOvTc2ultMpFi1w==}
+  '@smithy/config-resolver@4.5.1':
+    resolution: {integrity: sha512-abXk3LhODsvRHsk0ZS9ztrg/fZatTa9Z/z4pgx65YSLR+rY6kvUG/1IgcDKEUciR8MfdnkT5oPeHJTy/HhzDIQ==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/credential-provider-imds@4.2.14':
-    resolution: {integrity: sha512-Au28zBN48ZAoXdooGUHemuVBrkE+Ie6RPmGNIAJsFqj33Vhb6xAgRifUydZ2aY+M+KaMAETAlKk5NC5h1G7wpg==}
+  '@smithy/core@3.24.1':
+    resolution: {integrity: sha512-3mT7o4qQyUWttYnVK3A0Z/u3Xha3E81tXn32Tz6vjZiUXhBrkEivpw1hBYfh84iFF9CSzkBU9Y1DJ3Q6RQ231g==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/eventstream-codec@4.2.14':
-    resolution: {integrity: sha512-erZq0nOIpzfeZdCyzZjdJb4nVSKLUmSkaQUVkRGQTXs30gyUGeKnrYEg+Xe1W5gE3aReS7IgsvANwVPxSzY6Pw==}
+  '@smithy/credential-provider-imds@4.3.1':
+    resolution: {integrity: sha512-0S/acwHnqX4WrjXzhdiDRxsG2s9SC0cpPIK9nZ1R6UOHd+j7uL28+4bHu22urbLk2TVw3fkp6na/+fkUt/pLNQ==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/eventstream-serde-browser@4.2.14':
-    resolution: {integrity: sha512-8IelTCtTctWRbb+0Dcy+C0aICh1qa0qWXqgjcXDmMuCvPJRnv26hiDZoAau2ILOniki65mCPKqOQs/BaWvO4CQ==}
+  '@smithy/eventstream-serde-browser@4.3.1':
+    resolution: {integrity: sha512-X7MyI1fu8M84IPKk49kO4kb27Mqp6un9/0o/MsA1ngZ5OxxWKGUxPS3S/AJ9q1cPVTSGmRcbaGNfGUSsflTJkg==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/eventstream-serde-config-resolver@4.3.14':
-    resolution: {integrity: sha512-sqHiHpYRYo3FJlaIxD1J8PhbcmJAm7IuM16mVnwSkCToD7g00IBZzKuiLNMGmftULmEUX6/UAz8/NN5uMP8bVA==}
+  '@smithy/eventstream-serde-config-resolver@4.4.1':
+    resolution: {integrity: sha512-JZGbSXaBk7JY8VPzsh66ksJ0nTWXbApduFDkA/pEl3aTm2EoAiUZE1Iltp6c+X1bB8kxPQW0mHDfVdYCpWTOzg==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/eventstream-serde-node@4.2.14':
-    resolution: {integrity: sha512-Ht/8BuGlKfFTy0H3+8eEu0vdpwGztCnaLLXtpXNdQqiR7Hj4vFScU3T436vRAjATglOIPjJXronY+1WxxNLSiw==}
+  '@smithy/eventstream-serde-node@4.3.1':
+    resolution: {integrity: sha512-6Cn4xTNVxn9PWTHSbvf8zmcDhQW8lrLE1Xq5CJgmX6wEvdjS2S0KuE79Aiznv/jx51jpFJ98OuWyE+Bt+oG1MQ==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/eventstream-serde-universal@4.2.14':
-    resolution: {integrity: sha512-lWyt4T2XQZUZgK3tQ3Wn0w3XBvZsK/vjTuJl6bXbnGZBHH0ZUSONTYiK9TgjTTzU54xQr3DRFwpjmhp0oLm3gg==}
+  '@smithy/fetch-http-handler@5.4.1':
+    resolution: {integrity: sha512-r7bN6spQ+caZC8AnyvSxkRUb57zt2jhhRw3Z+2Ez8hjq6coIikDBFUUI/+CQ1xx9K6eX1Gx6wUKo4ylU66TIqw==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/fetch-http-handler@5.3.17':
-    resolution: {integrity: sha512-bXOvQzaSm6MnmLaWA1elgfQcAtN4UP3vXqV97bHuoOrHQOJiLT3ds6o9eo5bqd0TJfRFpzdGnDQdW3FACiAVdw==}
+  '@smithy/hash-blob-browser@4.3.1':
+    resolution: {integrity: sha512-2fbltQVQYmGd0OzPv2oDMRF0pxkzeIx8cbpx2x6W3UJWGaEyUzVPxF4d0sDXZ/r2obg+RbTyhTidXWlPDsKRKw==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/hash-blob-browser@4.2.15':
-    resolution: {integrity: sha512-0PJ4Al3fg2nM4qKrAIxyNcApgqHAXcBkN8FeizOz69z0rb26uZ6lMESYtxegaTlXB5Hj84JfwMPavMrwDMjucA==}
+  '@smithy/hash-node@4.3.1':
+    resolution: {integrity: sha512-u0/zo11mg7yNneoYgTkH4sXwSmcBpbl49o4UNCtQ7hYsXxynsN25KYHmXzqi7TPk5HQL5klGnpU5koOY0O+9hw==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/hash-node@4.2.14':
-    resolution: {integrity: sha512-8ZBDY2DD4wr+GGjTpPtiglEsqr0lUP+KHqgZcWczFf6qeZ/YRjMIOoQWVQlmwu7EtxKTd8YXD8lblmYcpBIA1g==}
+  '@smithy/hash-stream-node@4.3.1':
+    resolution: {integrity: sha512-4NOnngIoXngbJw9By3u8KXRgqt4vYATpAobNBnNWxOREP7JY3kB0bUmbBNhZ7dtZV/b4auO1eFMD4cLj9OauVg==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/hash-stream-node@4.2.14':
-    resolution: {integrity: sha512-tw4GANWkZPb6+BdD4Fgucqzey2+r73Z/GRo9zklsCdwrnxxumUV83ZIaBDdudV4Ylazw3EPTiJZhpX42105ruQ==}
-    engines: {node: '>=18.0.0'}
-
-  '@smithy/invalid-dependency@4.2.14':
-    resolution: {integrity: sha512-c21qJiTSb25xvvOp+H2TNZzPCngrvl5vIPqPB8zQ/DmJF4QWXO19x1dWfMJZ6wZuuWUPPm0gV8C0cU3+ifcWuw==}
+  '@smithy/invalid-dependency@4.3.1':
+    resolution: {integrity: sha512-cLmwtDoulyZvRepAfyV+3rx5oMvuh51dbE+6En3vGC09j3uVSRt1U4oguNu32ub3soGX0oYtBs8E7S2Q4SxTqg==}
     engines: {node: '>=18.0.0'}
 
   '@smithy/is-array-buffer@2.2.0':
     resolution: {integrity: sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA==}
     engines: {node: '>=14.0.0'}
 
-  '@smithy/is-array-buffer@4.2.2':
-    resolution: {integrity: sha512-n6rQ4N8Jj4YTQO3YFrlgZuwKodf4zUFs7EJIWH86pSCWBaAtAGBFfCM7Wx6D2bBJ2xqFNxGBSrUWswT3M0VJow==}
+  '@smithy/is-array-buffer@4.3.1':
+    resolution: {integrity: sha512-9aVG6VjOFVFHC6Z4hGAzIIrsVWpp1QOO4ERQ2k1S19VrgCamUGIBE2ilAnMWCfr+mlowHlLRXBStsTk/2c5HfA==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/md5-js@4.2.14':
-    resolution: {integrity: sha512-V2v0vx+h0iUSNG1Alt+GNBMSLGCrl9iVsdd+Ap67HPM9PN479x12V8LkuMoKImNZxn3MXeuyUjls+/7ZACZghA==}
+  '@smithy/md5-js@4.3.1':
+    resolution: {integrity: sha512-98NalujRdzv6ggVQNYPWpL2K57UKeUB8roIr61u6+JiHd7KUlMQ+sn/vk6IG4XxEjw2vlC7eu/xjYXshUE4XXg==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/middleware-content-length@4.2.14':
-    resolution: {integrity: sha512-xhHq7fX4/3lv5NHxLUk3OeEvl0xZ+Ek3qIbWaCL4f9JwgDZEclPBElljaZCAItdGPQl/kSM4LPMOpy1MYgprpw==}
+  '@smithy/middleware-content-length@4.3.1':
+    resolution: {integrity: sha512-l4BUIP+wljW/Ar+0/QcGdmElI9lalrywfzNijXMBG34Z510FRzPyrDLx/blNTZOAm0C4Mvx5t/bf760CZo1ajg==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/middleware-endpoint@4.4.31':
-    resolution: {integrity: sha512-KJPdCIN2kOE2aGmqZd7eUTr4WQwOGgtLWgUkswGJggs7rBcQYQjcZMEDa3C0DwbOiXS9L8/wDoQHkfxBYLfiLw==}
+  '@smithy/middleware-endpoint@4.5.1':
+    resolution: {integrity: sha512-qtqu5TS+8Y18ZDkJoiXN5AMW1G4JAg1+xytzpsUvIR5a4EUsgd5HQg12lekEHWpm2TDUmOgg+hBaHK7dvyWdkA==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/middleware-retry@4.5.4':
-    resolution: {integrity: sha512-/z7nIFK+ZRW3Ie/l3NEVGdy34LvmEOzBrtBAvgWZ/4PrKX0xP3kWm8pkfcwUk523SqxZhdbQP9JSXgjF77Uhpw==}
+  '@smithy/middleware-retry@4.6.1':
+    resolution: {integrity: sha512-eTaQhxs0rfUuAkL2MSKrH8DTO7YCeAgrdN0B2/RAeuHmXQ+x52dk5qUBsi/jtcqe5LxItgq5AG5tI6Cp8c0sow==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/middleware-serde@4.2.19':
-    resolution: {integrity: sha512-Q6y+W9h3iYVMCKWDoVge+OC1LKFqbEKaq8SIWG2X2bWJRpd/6dDLyICcNLT6PbjH3Rr6bmg/SeDB25XFOFfeEw==}
+  '@smithy/middleware-serde@4.3.1':
+    resolution: {integrity: sha512-t7YtUe076zWVypVmy1rX91oKi2TFJCkpfFpfMhJFpEIRPP0iL9JxjeSyFQ+1bF45JUfDzOzslUJa150WcSrBug==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/middleware-stack@4.2.14':
-    resolution: {integrity: sha512-2dvkUKLuFdKsCRmOE4Mn63co0Djtsm+JMh0bYZQupN1pJwMeE8FmQmRLLzzEMN0dnNi7CDCYYH8F0EVwWiPBeA==}
+  '@smithy/middleware-stack@4.3.1':
+    resolution: {integrity: sha512-1jKwiKZxCMQNqmp4uVPYA6r+MLGjEtH07gnOUdPgbnjuOIrl/0JY/ICdpQtFgeBsQ/Up01gnSv8GYEL0fb8yvg==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/node-config-provider@4.3.14':
-    resolution: {integrity: sha512-S+gFjyo/weSVL0P1b9Ts8C/CwIfNCgUPikk3sl6QVsfE/uUuO+QsF+NsE/JkpvWqqyz1wg7HFdiaZuj5CoBMRg==}
+  '@smithy/node-config-provider@4.4.1':
+    resolution: {integrity: sha512-q7tDJEJXcaSG/8TVpu2f2l9bzxTzDM9geWmltbzsY6Hfh3yiuXXTpLIO8+zwYASPPVFaTJpdKwjSSjdoDoccgw==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/node-http-handler@4.6.0':
-    resolution: {integrity: sha512-P734cAoTFtuGfWa/R3jgBnGlURt2w9bYEBwQNMKf58sRM9RShirB2mKwLsVP+jlG/wxpCu8abv8NxdUts8tdLA==}
+  '@smithy/node-http-handler@4.7.1':
+    resolution: {integrity: sha512-BdEYko85f/ldp68uH8XEyIvo810xFk6eyPH81SRggTOApYHWA+Xu7B2EzLuHbe37WVLaUA7F1fWR3/zBeme2WA==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/property-provider@4.2.14':
-    resolution: {integrity: sha512-WuM31CgfsnQ/10i7NYr0PyxqknD72Y5uMfUMVSniPjbEPceiTErb4eIqJQ+pdxNEAUEWrewrGjIRjVbVHsxZiQ==}
+  '@smithy/property-provider@4.3.1':
+    resolution: {integrity: sha512-3NHoqVBhzpY2b4YBx9AqyKC4C8nnEjl5FyKuxrCjvnjinG0ODj+yg1xX360nNahT6wghYjSw1SooCt3kIdnqIA==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/protocol-http@5.3.14':
-    resolution: {integrity: sha512-dN5F8kHx8RNU0r+pCwNmFZyz6ChjMkzShy/zup6MtkRmmix4vZzJdW+di7x//b1LiynIev88FM18ie+wwPcQtQ==}
+  '@smithy/protocol-http@5.4.1':
+    resolution: {integrity: sha512-8irPNCQgYxcSFp1aGcnDNFkTwSA+xPUaFq9V/v1+JXWu8sKr5b3cFmg2kBTkjkvypDmGeNffuNu0x5iqw1NoAw==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/querystring-builder@4.2.14':
-    resolution: {integrity: sha512-XYA5Z0IqTeF+5XDdh4BBmSA0HvbgVZIyv4cmOoUheDNR57K1HgBp9ukUMx3Cr3XpDHHpLBnexPE3LAtDsZkj2A==}
+  '@smithy/shared-ini-file-loader@4.5.1':
+    resolution: {integrity: sha512-FKoKxVzdFPhyynFI+SPTWrgOP60fZ4l1UwukWYj4eyhpSmEI7MJ6p58hawIIt9bwp+aek9NEm8Zika7E+GEoeg==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/querystring-parser@4.2.14':
-    resolution: {integrity: sha512-hr+YyqBD23GVvRxGGrcc/oOeNlK3PzT5Fu4dzrDXxzS1LpFiuL2PQQqKPs87M79aW7ziMs+nvB3qdw77SqE7Lw==}
+  '@smithy/signature-v4@5.4.1':
+    resolution: {integrity: sha512-728lZZEWYWubBESrfntNslZQYDKRlJDY4dcDnYbL50+gu35pGPLblu4S0/RH/RDLF6me1M87ECHsHELGL7dA/Q==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/service-error-classification@4.3.0':
-    resolution: {integrity: sha512-9jKsBYQRPR0xBLgc2415RsA5PIcP2sis4oBdN9s0D13cg1B1284mNTjx9Yc+BEERXzuPm5ObktI96OxsKh8E9A==}
-    engines: {node: '>=18.0.0'}
-
-  '@smithy/shared-ini-file-loader@4.4.9':
-    resolution: {integrity: sha512-495/V2I15SHgedSJoDPD23JuSfKAp726ZI1V0wtjB07Wh7q/0tri/0e0DLefZCHgxZonrGKt/OCTpAtP1wE1kQ==}
-    engines: {node: '>=18.0.0'}
-
-  '@smithy/signature-v4@5.3.14':
-    resolution: {integrity: sha512-1D9Y/nmlVjCeSivCbhZ7hgEpmHyY1h0GvpSZt3l0xcD9JjmjVC1CHOozS6+Gh+/ldMH8JuJ6cujObQqfayAVFA==}
-    engines: {node: '>=18.0.0'}
-
-  '@smithy/smithy-client@4.12.12':
-    resolution: {integrity: sha512-daO7SJn4eM6ArbmrEs+/BTbH7af8AEbSL3OMQdcRvvn8tuUcR5rU2n6DgxIV53aXMS42uwK8NgKKCh5XgqYOPQ==}
+  '@smithy/smithy-client@4.13.1':
+    resolution: {integrity: sha512-IcznNM8Qd9u1X3oflp12tkzyOB4HbT+sfYWlWiyEysgNzSHoWcHUUsTT4y1jjDjtVuuVVQbYks+g1kVd7u1eGQ==}
     engines: {node: '>=18.0.0'}
 
   '@smithy/types@4.14.1':
     resolution: {integrity: sha512-59b5HtSVrVR/eYNei3BUj3DCPKD/G7EtDDe7OEJE7i7FtQFugYo6MxbotS8mVJkLNVf8gYaAlEBwwtJ9HzhWSg==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/url-parser@4.2.14':
-    resolution: {integrity: sha512-p06BiBigJ8bTA3MgnOfCtDUWnAMY0YfedO/GRpmc7p+wg3KW8vbXy1xwSu5ASy0wV7rRYtlfZOIKH4XqfhjSQQ==}
+  '@smithy/url-parser@4.3.1':
+    resolution: {integrity: sha512-tuelFlF2PZR/wogFC58NIrPOv+Zna4N1+3kA161/33D1Gbwvl6Nh4WsAsW05ZyPp0O6CMGsdbb0S2b/qVjRMCw==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-base64@4.3.2':
-    resolution: {integrity: sha512-XRH6b0H/5A3SgblmMa5ErXQ2XKhfbQB+Fm/oyLZ2O2kCUrwgg55bU0RekmzAhuwOjA9qdN5VU2BprOvGGUkOOQ==}
+  '@smithy/util-base64@4.4.1':
+    resolution: {integrity: sha512-fTHiwW2xbiRiWzfSk4IGAr3gNZCH4fuRYqt8+IuarsP/YON35576iVdePraZ6yJlFxlCL0eMec3/F7xYqoKzlg==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-body-length-browser@4.2.2':
-    resolution: {integrity: sha512-JKCrLNOup3OOgmzeaKQwi4ZCTWlYR5H4Gm1r2uTMVBXoemo1UEghk5vtMi1xSu2ymgKVGW631e2fp9/R610ZjQ==}
+  '@smithy/util-body-length-browser@4.3.1':
+    resolution: {integrity: sha512-1scg5t4nV3hV7CZs996/XHb80aDZ5YotH4NcvkW/w/rHj+cSz0aCIzwz8aUNKB4nCDPSHRCbrKoj+TvycYefmw==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-body-length-node@4.2.3':
-    resolution: {integrity: sha512-ZkJGvqBzMHVHE7r/hcuCxlTY8pQr1kMtdsVPs7ex4mMU+EAbcXppfo5NmyxMYi2XU49eqaz56j2gsk4dHHPG/g==}
+  '@smithy/util-body-length-node@4.3.1':
+    resolution: {integrity: sha512-VRC8MKVPKrgUYThTA7ughcKMfjW6/X92H0wXGJoda0Apw4O5xbXL0GMLz40DTWlsb5hh2iItk6+XL72uJdxYcw==}
     engines: {node: '>=18.0.0'}
 
   '@smithy/util-buffer-from@2.2.0':
     resolution: {integrity: sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA==}
     engines: {node: '>=14.0.0'}
 
-  '@smithy/util-buffer-from@4.2.2':
-    resolution: {integrity: sha512-FDXD7cvUoFWwN6vtQfEta540Y/YBe5JneK3SoZg9bThSoOAC/eGeYEua6RkBgKjGa/sz6Y+DuBZj3+YEY21y4Q==}
-    engines: {node: '>=18.0.0'}
-
-  '@smithy/util-config-provider@4.2.2':
-    resolution: {integrity: sha512-dWU03V3XUprJwaUIFVv4iOnS1FC9HnMHDfUrlNDSh4315v0cWyaIErP8KiqGVbf5z+JupoVpNM7ZB3jFiTejvQ==}
-    engines: {node: '>=18.0.0'}
-
-  '@smithy/util-defaults-mode-browser@4.3.48':
-    resolution: {integrity: sha512-hxVRVPYaRDWa6YQdse1aWX1qrksmLsvNyGBKdc32q4jFzSjxYVNWfstknAfR228TnzS4tzgswXRuYIbhXBuXFQ==}
-    engines: {node: '>=18.0.0'}
-
-  '@smithy/util-defaults-mode-node@4.2.53':
-    resolution: {integrity: sha512-ybgCk+9JdBq8pYC8Y6U5fjyS8e4sboyAShetxPNL0rRBtaVl56GSFAxsolVBIea1tXR4LPIzL8i6xqmcf0+DCQ==}
+  '@smithy/util-config-provider@4.3.1':
+    resolution: {integrity: sha512-lw6L5GF5+W19vO6o3fZwRT2cXEG+8b2LH0b9ppjDT6nIxjUgmljEQGninx5XorylwKZZ4XLVABeroJ8oaF9RmQ==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-endpoints@3.4.2':
-    resolution: {integrity: sha512-a55Tr+3OKld4TTtnT+RhKOQHyPxm3j/xL4OR83WBUhLJaKDS9dnJ7arRMOp3t31dcLhApwG9bgvrRXBHlLdIkg==}
+  '@smithy/util-defaults-mode-browser@4.4.1':
+    resolution: {integrity: sha512-1rA7w+LjK1WJClsffC81Z/ZtjFt22QsKhBjUYEnZsGVS2nOTfOENKBzdg4SxhdwFvBCjcbpjscUfXOPwE3UHWQ==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-hex-encoding@4.2.2':
-    resolution: {integrity: sha512-Qcz3W5vuHK4sLQdyT93k/rfrUwdJ8/HZ+nMUOyGdpeGA1Wxt65zYwi3oEl9kOM+RswvYq90fzkNDahPS8K0OIg==}
+  '@smithy/util-defaults-mode-node@4.3.1':
+    resolution: {integrity: sha512-1fk1wfQHBenQD5NitVKOFgW0wsISYAFPIXGyStJWAeCtMyRhgHYvtJxBk2rwGWA0L5QX6oM6yeHSLKPFMk59ww==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-middleware@4.2.14':
-    resolution: {integrity: sha512-1Su2vj9RYNDEv/V+2E+jXkkwGsgR7dc4sfHn9Z7ruzQHJIEni9zzw5CauvRXlFJfmgcqYP8fWa0dkh2Q2YaQyw==}
+  '@smithy/util-endpoints@3.5.1':
+    resolution: {integrity: sha512-yORYzJD5zoGbSDkAACr0dIjDiSEA3X8h8lggDENl1dkKpCG0TQIoItPBqtvuJHzFFjRXumcoH+/09xIuixGyCw==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-retry@4.3.3':
-    resolution: {integrity: sha512-idjUvd4M9Jj6rXkhqw4H4reHoweuK4ZxYWyOrEp4N2rOF5VtaOlQGLDQJva/8WanNXk9ScQtsAb7o5UHGvFm4A==}
+  '@smithy/util-middleware@4.3.1':
+    resolution: {integrity: sha512-SRRMDcIgVXVhVbxviBaSZbuWuVW3jD08wv4ESV0V2oiw0Mki8TPVQ5IxwD3MvSTPg52QYsRP+JoMw5WdUdeWAg==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-stream@4.5.24':
-    resolution: {integrity: sha512-na5vv2mBSDzXewLEEoWGI7LQQkfpmFEomBsmOpzLFjqGctm0iMwXY5lAwesY9pIaErkccW0qzEOUcYP+WKneXg==}
+  '@smithy/util-retry@4.4.1':
+    resolution: {integrity: sha512-qkgWgwn1xw0GoY9Ea/B6FrYSPfHA0zyOtJkokwxZuvucRf2+2lfTut6adi4e4Y7LEAaxsFG7r6i05mtDCxbHKA==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-uri-escape@4.2.2':
-    resolution: {integrity: sha512-2kAStBlvq+lTXHyAZYfJRb/DfS3rsinLiwb+69SstC9Vb0s9vNWkRwpnj918Pfi85mzi42sOqdV72OLxWAISnw==}
+  '@smithy/util-stream@4.6.1':
+    resolution: {integrity: sha512-GjZfEft0M0V3n2YM/LGkr5LeLd8gxHUIzW0rUz6VtTtlAq245GxHlJghvoPEjJHKTj255iHFAiA4IsIdK40Ueg==}
     engines: {node: '>=18.0.0'}
 
   '@smithy/util-utf8@2.3.0':
     resolution: {integrity: sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A==}
     engines: {node: '>=14.0.0'}
 
-  '@smithy/util-utf8@4.2.2':
-    resolution: {integrity: sha512-75MeYpjdWRe8M5E3AW0O4Cx3UadweS+cwdXjwYGBW5h/gxxnbeZ877sLPX/ZJA9GVTlL/qG0dXP29JWFCD1Ayw==}
+  '@smithy/util-utf8@4.3.1':
+    resolution: {integrity: sha512-FtRrSnriXtOs4+J8/y9SbQ1xmN71hrOsN/YJr5PQQj5nR1l7YNkGS/TEk4gr0WN7gyrUqw8/RFaYVjI18732ZA==}
     engines: {node: '>=18.0.0'}
 
-  '@smithy/util-waiter@4.2.16':
-    resolution: {integrity: sha512-GtclrKoZ3Lt7jPQ7aTIYKfjY92OgceScftVnkTsG8e1KV8rkvZgN+ny6YSRhd9hxB8rZtwVbmln7NTvE5O3GmQ==}
-    engines: {node: '>=18.0.0'}
-
-  '@smithy/uuid@1.1.2':
-    resolution: {integrity: sha512-O/IEdcCUKkubz60tFbGA7ceITTAJsty+lBjNoorP4Z6XRqaFb/OjQjZODophEcuq68nKm6/0r+6/lLQ+XVpk8g==}
+  '@smithy/util-waiter@4.4.1':
+    resolution: {integrity: sha512-G/gWDykZNL0NVcd1qXkoKm45jxJECp6q53DSomM5QKMsyAMEsGksVq+HwgonqYxfFJEzzHi6ljtWKXVS1pl0/Q==}
     engines: {node: '>=18.0.0'}
 
   '@so-ric/colorspace@1.1.6':
@@ -2280,8 +2127,8 @@ packages:
   '@tsconfig/node16@1.0.4':
     resolution: {integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==}
 
-  '@tybys/wasm-util@0.10.1':
-    resolution: {integrity: sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==}
+  '@tybys/wasm-util@0.10.2':
+    resolution: {integrity: sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg==}
 
   '@types/babel__core@7.20.5':
     resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==}
@@ -2304,11 +2151,8 @@ packages:
   '@types/chai@4.3.20':
     resolution: {integrity: sha512-/pC9HAB5I/xMlc5FP77qjCnI16ChlJfW0tGa0IUcFn38VJrTV6DeZ60NU5KZBtaOZqjdpwTWohz5HU1RrhiYxQ==}
 
-  '@types/estree@1.0.8':
-    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
-
-  '@types/flat@5.0.5':
-    resolution: {integrity: sha512-nPLljZQKSnac53KDUDzuzdRfGI0TDb5qPrb+SrQyN3MtdQrOnGsKniHN1iYZsJEBIVQve94Y6gNz22sgISZq+Q==}
+  '@types/estree@1.0.9':
+    resolution: {integrity: sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==}
 
   '@types/fs-extra@11.0.4':
     resolution: {integrity: sha512-yTbItCNreRooED33qjunPthRcSjERP1r4MqCZc7wv0u2sUkzTFp45tgUfS5+r7FrZPdmCCNflLhVSP/o+SemsQ==}
@@ -2373,11 +2217,11 @@ packages:
   '@types/node@18.19.130':
     resolution: {integrity: sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg==}
 
-  '@types/node@20.19.39':
-    resolution: {integrity: sha512-orrrD74MBUyK8jOAD/r0+lfa1I2MO6I+vAkmAWzMYbCcgrN4lCrmK52gRFQq/JRxfYPfonkr4b0jcY7Olqdqbw==}
+  '@types/node@20.19.41':
+    resolution: {integrity: sha512-ECymXOukMnOoVkC2bb1Vc/w/836DXncOg5m8Xj1RH7xSHZJWNYY6Zh7EH477vcnD5egKNNfy2RpNOmuChhFPgQ==}
 
-  '@types/node@22.19.17':
-    resolution: {integrity: sha512-wGdMcf+vPYM6jikpS/qhg6WiqSV/OhG+jeeHT/KlVqxYfD40iYJf9/AE1uQxVWFvU7MipKRkRv8NSHiCGgPr8Q==}
+  '@types/node@22.19.19':
+    resolution: {integrity: sha512-dyh/xO2Fh5bYrfWaaqGrRQQGkNdmYw6AmaAUvYeUMNTWQtvb796ikLdmTchRmOlOiIJ1TDXfWgVx1QkUlQ6Hew==}
 
   '@types/normalize-package-data@2.4.4':
     resolution: {integrity: sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA==}
@@ -2452,11 +2296,11 @@ packages:
       typescript:
         optional: true
 
-  '@typescript-eslint/eslint-plugin@8.59.0':
-    resolution: {integrity: sha512-HyAZtpdkgZwpq8Sz3FSUvCR4c+ScbuWa9AksK2Jweub7w4M3yTz4O11AqVJzLYjy/B9ZWPyc81I+mOdJU/bDQw==}
+  '@typescript-eslint/eslint-plugin@8.59.3':
+    resolution: {integrity: sha512-PwFvSKsXGShKGW6n5bZOhGHEcCZXM8HofLK9fNsEwZXzFRjoY+XT1Vsf1zgyXdwTr0ZYz1/2tkZ0DBTT9jZjhw==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
-      '@typescript-eslint/parser': ^8.59.0
+      '@typescript-eslint/parser': ^8.59.3
       eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
       typescript: '>=4.8.4 <6.1.0'
 
@@ -2470,15 +2314,15 @@ packages:
       typescript:
         optional: true
 
-  '@typescript-eslint/parser@8.59.0':
-    resolution: {integrity: sha512-TI1XGwKbDpo9tRW8UDIXCOeLk55qe9ZFGs8MTKU6/M08HWTw52DD/IYhfQtOEhEdPhLMT26Ka/x7p70nd3dzDg==}
+  '@typescript-eslint/parser@8.59.3':
+    resolution: {integrity: sha512-HPwA+hVkfcriajbNvTmZv4VRauibay+cWArYUYq7u7W7PmGShMxbPxLvrwDme55a6d5alG3nrYfhyJ/G28XlLg==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
       typescript: '>=4.8.4 <6.1.0'
 
-  '@typescript-eslint/project-service@8.59.0':
-    resolution: {integrity: sha512-Lw5ITrR5s5TbC19YSvlr63ZfLaJoU6vtKTHyB0GQOpX0W7d5/Ir6vUahWi/8Sps/nOukZQ0IB3SmlxZnjaKVnw==}
+  '@typescript-eslint/project-service@8.59.3':
+    resolution: {integrity: sha512-ECiUWa/KYRGDFUqTNehaRgzDshnJfkTABJxVemHk4ko22gcr0ukloKjWvyQ64g8YCV/UI47kN1dbmjf/GaQYng==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       typescript: '>=4.8.4 <6.1.0'
@@ -2495,12 +2339,12 @@ packages:
     resolution: {integrity: sha512-jjhdIE/FPF2B7Z1uzc6i3oWKbGcHb87Qw7AWj6jmEqNOfDFbJWtjt/XfwCpvNkpGWlcJaog5vTR+VV8+w9JflA==}
     engines: {node: ^18.18.0 || >=20.0.0}
 
-  '@typescript-eslint/scope-manager@8.59.0':
-    resolution: {integrity: sha512-UzR16Ut8IpA3Mc4DbgAShlPPkVm8xXMWafXxB0BocaVRHs8ZGakAxGRskF7FId3sdk9lgGD73GSFaWmWFDE4dg==}
+  '@typescript-eslint/scope-manager@8.59.3':
+    resolution: {integrity: sha512-t2LvZnoEfzKtnPjgeEu41xw5gxq9mQVfYy4OoZ4Vlt0sk3JwxmhCca/AR7DwOiHrjWgjAj6as4AhRLKSDfvZIA==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@typescript-eslint/tsconfig-utils@8.59.0':
-    resolution: {integrity: sha512-91Sbl3s4Kb3SybliIY6muFBmHVv+pYXfybC4Oolp3dvk8BvIE3wOPc+403CWIT7mJNkfQRGtdqghzs2+Z91Tqg==}
+  '@typescript-eslint/tsconfig-utils@8.59.3':
+    resolution: {integrity: sha512-PcIJHjmaREXLgIAIzLnSY9VucEzz8FKXsRgFa1DmdGCK/5tJpW03TKJF01Q6VZd1lLdz2sIKPWaDUZN9dp//dw==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       typescript: '>=4.8.4 <6.1.0'
@@ -2525,8 +2369,8 @@ packages:
       typescript:
         optional: true
 
-  '@typescript-eslint/type-utils@8.59.0':
-    resolution: {integrity: sha512-3TRiZaQSltGqGeNrJzzr1+8YcEobKH9rHnqIp/1psfKFmhRQDNMGP5hBufanYTGznwShzVLs3Mz+gDN7HkWfXg==}
+  '@typescript-eslint/type-utils@8.59.3':
+    resolution: {integrity: sha512-g71d8QD8UaiHGvrJwyIS1hCX5r63w6Jll+4VEYhEAHXTDIqX1JgxhTAbEHtKntL9kuc4jRo7/GWw5xfCepSccQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
@@ -2544,8 +2388,8 @@ packages:
     resolution: {integrity: sha512-iZqi+Ds1y4EDYUtlOOC+aUmxnE9xS/yCigkjA7XpTKV6nCBd3Hp/PRGGmdwnfkV2ThMyYldP1wRpm/id99spTQ==}
     engines: {node: ^18.18.0 || >=20.0.0}
 
-  '@typescript-eslint/types@8.59.0':
-    resolution: {integrity: sha512-nLzdsT1gdOgFxxxwrlNVUBzSNBEEHJ86bblmk4QAS6stfig7rcJzWKqCyxFy3YRRHXDWEkb2NralA1nOYkkm/A==}
+  '@typescript-eslint/types@8.59.3':
+    resolution: {integrity: sha512-ePFoH0g4ludssdRFqqDxQePCxU4WQyRa9+XVwjm7yLn0FKhMeoetC+qBEEI1Eyb1pGSDveTIT09Bvw2WhlGayg==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   '@typescript-eslint/typescript-estree@5.62.0':
@@ -2575,8 +2419,8 @@ packages:
       typescript:
         optional: true
 
-  '@typescript-eslint/typescript-estree@8.59.0':
-    resolution: {integrity: sha512-O9Re9P1BmBLFJyikRbQpLku/QA3/AueZNO9WePLBwQrvkixTmDe8u76B6CYUAITRl/rHawggEqUGn5QIkVRLMw==}
+  '@typescript-eslint/typescript-estree@8.59.3':
+    resolution: {integrity: sha512-CbRjVRAf7Lr9Kr8RopKcbY45p2VfmmHrm0ygOCYFi7oU8q19m0Fs/6iHS7kNOmwpp+ob07ZVcAqlxUod9lYdmg==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       typescript: '>=4.8.4 <6.1.0'
@@ -2599,8 +2443,8 @@ packages:
     peerDependencies:
       eslint: ^8.56.0
 
-  '@typescript-eslint/utils@8.59.0':
-    resolution: {integrity: sha512-I1R/K7V07XsMJ12Oaxg/O9GfrysGTmCRhvZJBv0RE0NcULMzjqVpR5kRRQjHsz3J/bElU7HwCO7zkqL+MSUz+g==}
+  '@typescript-eslint/utils@8.59.3':
+    resolution: {integrity: sha512-JAvT14goBzRzzzZyqq3P9BLArIxTtQURUtFgQ/V7FO+eU+Gg6ES+5ymOPP1wRxXcxAYeivCk4uS3jCKWI1K8Zg==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
@@ -2618,12 +2462,12 @@ packages:
     resolution: {integrity: sha512-cDF0/Gf81QpY3xYyJKDV14Zwdmid5+uuENhjH2EqFaF0ni+yAyq/LzMaIJdhNJXZI7uLzwIlA+V7oWoyn6Curg==}
     engines: {node: ^18.18.0 || >=20.0.0}
 
-  '@typescript-eslint/visitor-keys@8.59.0':
-    resolution: {integrity: sha512-/uejZt4dSere1bx12WLlPfv8GktzcaDtuJ7s42/HEZ5zGj9oxRaD4bj7qwSunXkf+pbAhFt2zjpHYUiT5lHf0Q==}
+  '@typescript-eslint/visitor-keys@8.59.3':
+    resolution: {integrity: sha512-f1UQF7ggd42YiwI5wGrRaPsa+P0CINBlrkLPmGfpq/u/I/oVtecoEIfFR9ag/oa1sLOsRNZ6xehf6qMZhQGBDg==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@ungap/structured-clone@1.3.0':
-    resolution: {integrity: sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==}
+  '@ungap/structured-clone@1.3.1':
+    resolution: {integrity: sha512-mUFwbeTqrVgDQxFveS+df2yfap6iuP20NAKAsBt5jDEoOTDew+zwLAOilHCeQJOVSvmgCX4ogqIrA0mnyr08yQ==}
 
   '@unrs/resolver-binding-android-arm-eabi@1.11.1':
     resolution: {integrity: sha512-ppLRUgHVaGRWUx0R0Ut06Mjo9gBaBkg3v/8AxusGLhsIotbBLuRk51rAzqLC8gq6NyyAojEXglNjzf6R948DNw==}
@@ -2750,11 +2594,11 @@ packages:
       ajv:
         optional: true
 
-  ajv@6.14.0:
-    resolution: {integrity: sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==}
+  ajv@6.15.0:
+    resolution: {integrity: sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==}
 
-  ajv@8.18.0:
-    resolution: {integrity: sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==}
+  ajv@8.20.0:
+    resolution: {integrity: sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==}
 
   ansi-colors@4.1.3:
     resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==}
@@ -2970,8 +2814,8 @@ packages:
   base64-js@1.5.1:
     resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
 
-  baseline-browser-mapping@2.10.20:
-    resolution: {integrity: sha512-1AaXxEPfXT+GvTBJFuy4yXVHWJBXa4OdbIebGN/wX5DlsIkU0+wzGnd2lOzokSk51d5LUmqjgBLRLlypLUqInQ==}
+  baseline-browser-mapping@2.10.29:
+    resolution: {integrity: sha512-Asa2krT+XTPZINCS+2QcyS8WTkObE77RwkydwF7h6DmnKqbvlalz93m/dnphUyCa6SWSP51VgtEUf2FN+gelFQ==}
     engines: {node: '>=6.0.0'}
     hasBin: true
 
@@ -2997,8 +2841,8 @@ packages:
   brace-expansion@2.1.0:
     resolution: {integrity: sha512-TN1kCZAgdgweJhWWpgKYrQaMNHcDULHkWwQIspdtjV4Y5aurRdZpjAqn6yX3FPqTA9ngHCc4hJxMAMgGfve85w==}
 
-  brace-expansion@5.0.5:
-    resolution: {integrity: sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==}
+  brace-expansion@5.0.6:
+    resolution: {integrity: sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==}
     engines: {node: 18 || 20 || >=22}
 
   braces@3.0.3:
@@ -3082,8 +2926,8 @@ packages:
     resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==}
     engines: {node: '>=10'}
 
-  caniuse-lite@1.0.30001790:
-    resolution: {integrity: sha512-bOoxfJPyYo+ds6W0YfptaCWbFnJYjh2Y1Eow5lRv+vI2u8ganPZqNm1JwNh0t2ELQCqIWg4B3dWEusgAmsoyOw==}
+  caniuse-lite@1.0.30001792:
+    resolution: {integrity: sha512-hVLMUZFgR4JJ6ACt1uEESvQN1/dBVqPAKY0hgrV70eN3391K6juAfTjKZLKvOMsx8PxA7gsY1/tLMMTcfFLLpw==}
 
   capital-case@1.0.4:
     resolution: {integrity: sha512-ds37W8CytHgwnhGGTi88pcPyR15qoNkOpYwmMMfnWqqWgESapLqvDx6huFjQ5vqWSn2Z06173XNA7LtMOeUh1A==}
@@ -3533,8 +3377,8 @@ packages:
     engines: {node: '>=0.10.0'}
     hasBin: true
 
-  electron-to-chromium@1.5.343:
-    resolution: {integrity: sha512-YHnQ3MXI08icvL9ZKnEBy05F2EQ8ob01UaMOuMbM8l+4UcAq6MPPbBTJBbsBUg3H8JeZNt+O4fjsoWth3p6IFg==}
+  electron-to-chromium@1.5.354:
+    resolution: {integrity: sha512-JaBHwWcfIdmSAfWM5l3uwjGd431j8YEMikZ+K/2nXVuBqJKyZ0f+2h4n4JY5AyNiZmnY9qQr2RU3v9DxDmHMNg==}
 
   elegant-spinner@1.0.1:
     resolution: {integrity: sha512-B+ZM+RXvRqQaAmkMlO/oSe5nMUOaUnyfGYCEHoR8wrXsZR2mA0XVibsxV1bvTwxdRWah1PkQqso2EzhILGHtEQ==}
@@ -3553,8 +3397,8 @@ packages:
   end-of-stream@1.4.5:
     resolution: {integrity: sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==}
 
-  enhanced-resolve@5.20.1:
-    resolution: {integrity: sha512-Qohcme7V1inbAfvjItgw0EaxVX5q2rdVEZHRBrEQdRZTssLDGsL8Lwrznl8oQ/6kuTJONLaDcGjkNP247XEhcA==}
+  enhanced-resolve@5.21.3:
+    resolution: {integrity: sha512-QyL119InA+XXEkNLNTPCXPugSvOfhwv0JOlGNzvxs0hZaiHLNvXSpudUWsOlsXGWJh8G6ckCScEkVHfX3kw/2Q==}
     engines: {node: '>=10.13.0'}
 
   entities@4.5.0:
@@ -3602,11 +3446,6 @@ packages:
   es6-promise@4.2.8:
     resolution: {integrity: sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w==}
 
-  esbuild@0.27.7:
-    resolution: {integrity: sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w==}
-    engines: {node: '>=18'}
-    hasBin: true
-
   escalade@3.2.0:
     resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}
     engines: {node: '>=6'}
@@ -3638,8 +3477,8 @@ packages:
     resolution: {integrity: sha512-NNTyyolSmKJicgxtoWZ/hoy2Rw56WIoWCFxgnBkXqDgi9qPKMwZs2Nx2b6SHLJvCiWWhZhWr5V46CFPo3PSPag==}
     engines: {node: '>=18.0.0'}
 
-  eslint-config-oclif@6.0.159:
-    resolution: {integrity: sha512-tzfcFO1kYLJeuSgM4QOVW/GJROeAcd5Nwzx5dwonK4FECoKAArjZQ5ZY7Z+uK/nAABIym5ihxWgdkSrgqbJARg==}
+  eslint-config-oclif@6.0.164:
+    resolution: {integrity: sha512-LEJRa/q7FAIH8zeZJ16E3RghSU/kZEa6oBV8kxTSE57djsgSNcwf92NbhcPj6RaQ/eANIva8nWJ9h+FeeWUlew==}
     engines: {node: '>=18.18.0'}
 
   eslint-config-xo-space@0.35.0:
@@ -3919,14 +3758,14 @@ packages:
   fast-levenshtein@3.0.0:
     resolution: {integrity: sha512-hKKNajm46uNmTlhHSyZkmToAc56uZJwYq7yrciZjqOxnlfQwERDQJmHPUp7m1m9wx8vgOe8IaCKZ5Kv2k1DdCQ==}
 
-  fast-uri@3.1.0:
-    resolution: {integrity: sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==}
+  fast-uri@3.1.2:
+    resolution: {integrity: sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ==}
 
-  fast-xml-builder@1.1.5:
-    resolution: {integrity: sha512-4TJn/8FKLeslLAH3dnohXqE3QSoxkhvaMzepOIZytwJXZO69Bfz0HBdDHzOTOon6G59Zrk6VQ2bEiv1t61rfkA==}
+  fast-xml-builder@1.2.0:
+    resolution: {integrity: sha512-00aAWieqff+ZJhsXA4g1g7M8k+7AYoMUUHF+/zFb5U6Uv/P0Vl4QZo84/IcufzYalLuEj9928bXN9PbbFzMF0Q==}
 
-  fast-xml-parser@5.5.8:
-    resolution: {integrity: sha512-Z7Fh2nVQSb2d+poDViM063ix2ZGt9jmY1nWhPfHBOK2Hgnb/OW3P4Et3P/81SEej0J7QbWtJqxO05h8QYfK7LQ==}
+  fast-xml-parser@5.7.2:
+    resolution: {integrity: sha512-P7oW7tLbYnhOLQk/Gv7cZgzgMPP/XN03K02/Jy6Y/NHzyIAIpxuZIM/YqAkfiXFPxA2CTm7NtCijK9EDu09u2w==}
     hasBin: true
 
   fastest-levenshtein@1.0.16:
@@ -4063,8 +3902,8 @@ packages:
   fromentries@1.3.2:
     resolution: {integrity: sha512-cHEpEQHUg0f8XdtZCc2ZAhrHzKzT0MrFUTcvx+hfxYu7rGMDc5SKoXFh+n4YigxsHXRzc6OrCshdR1bWH6HHyg==}
 
-  fs-extra@11.3.4:
-    resolution: {integrity: sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA==}
+  fs-extra@11.3.5:
+    resolution: {integrity: sha512-eKpRKAovdpZtR1WopLHxlBWvAgPny3c4gX1G5Jhwmmw4XJj0ifSD5qB5TOo8hmA0wlRKDAOAhEE1yVPgs6Fgcg==}
     engines: {node: '>=14.14'}
 
   fs-extra@8.1.0:
@@ -4417,8 +4256,8 @@ packages:
     resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==}
     engines: {node: '>= 0.4'}
 
-  is-core-module@2.16.1:
-    resolution: {integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==}
+  is-core-module@2.16.2:
+    resolution: {integrity: sha512-evOr8xfXKxE6qSR0hSXL2r3sd7ALj8+7jQEUvPYcm5sgZFdJ+AYzT6yNmJenvIYQBgIGwfwz08sL8zoL7yq2BA==}
     engines: {node: '>= 0.4'}
 
   is-data-view@1.0.2:
@@ -5008,8 +4847,8 @@ packages:
   lru-cache@10.4.3:
     resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}
 
-  lru-cache@11.3.5:
-    resolution: {integrity: sha512-NxVFwLAnrd9i7KUBxC4DrUhmgjzOs+1Qm50D3oF1/oL+r1NpZ4gA7xvG0/zJ8evR7zIKn4vLf7qTNduWFtCrRw==}
+  lru-cache@11.3.6:
+    resolution: {integrity: sha512-Gf/KoL3C/MlI7Bt0PGI9I+TeTC/I6r/csU58N4BSNc4lppLBeKsOdFYkK+dX0ABDUMJNfCHTyPpzwwO21Awd3A==}
     engines: {node: 20 || >=22}
 
   lru-cache@5.1.1:
@@ -5146,6 +4985,11 @@ packages:
     engines: {node: '>=10'}
     hasBin: true
 
+  mkdirp@2.1.6:
+    resolution: {integrity: sha512-+hEnITedc8LAtIP9u3HJDFIdcLV2vXP33sqLLIzkv1Db1zO/1OxbvYf0Y1OC/S/Qo5dxHXepofhmxL02PsKe+A==}
+    engines: {node: '>=10'}
+    hasBin: true
+
   mocha@10.8.2:
     resolution: {integrity: sha512-VZlYo/WE8t1tstuRmqgeyBgCbJc/lEdopaa+axcKzTBJ+UIdlAB9XnmvTCAH4pwR4ElNInaedhEBmZD8iCSVEg==}
     engines: {node: '>= 14.0.0'}
@@ -5213,8 +5057,8 @@ packages:
     resolution: {integrity: sha512-RM5oyBy45cLEoHqCeh+MNuFAxO0vTFBLskvQbOKnEE7YTTSN4tbN8QWDIPQ6L+WvKsB/qLEGpYe2ZZ9d4W9OIQ==}
     engines: {node: '>=8'}
 
-  node-releases@2.0.38:
-    resolution: {integrity: sha512-3qT/88Y3FbH/Kx4szpQQ4HzUbVrHPKTLVpVocKiLfoYvw9XSGOX2FmD2d6DrXbVYyAQTF2HeF6My8jmzx7/CRw==}
+  node-releases@2.0.44:
+    resolution: {integrity: sha512-5WUyunoPMsvvEhS8AxHtRzP+oA8UCkJ7YRxatWKjngndhDGLiqEVAQKWjFAiAiuL8zMRGzGSJxFnLetoa43qGQ==}
 
   normalize-package-data@2.5.0:
     resolution: {integrity: sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==}
@@ -5478,8 +5322,8 @@ packages:
     resolution: {integrity: sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==}
     engines: {node: '>=4'}
 
-  pnpm@10.33.0:
-    resolution: {integrity: sha512-EFaLtKavtYyes2MNqQzJUWQXq+vT+rvmc58K55VyjaFJHp21pUTHatjrdXD1xLs9bGN7LLQb/c20f6gjyGSTGQ==}
+  pnpm@10.33.4:
+    resolution: {integrity: sha512-HGezs1my1AgRm6HtKJ80uPw8aHNBK+xv0mT73IJInlEPy+y5zp0i2ufzt2Jp2EQQRgFL3KU7mXnNelYa1jG4AA==}
     engines: {node: '>=18.12'}
     hasBin: true
 
@@ -5809,8 +5653,8 @@ packages:
     resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
     hasBin: true
 
-  semver@7.7.4:
-    resolution: {integrity: sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==}
+  semver@7.8.0:
+    resolution: {integrity: sha512-AcM7dV/5ul4EekoQ29Agm5vri8JNqRyj39o0qpX6vDF2GZrtutZl5RwgD1XnZjiTAfncsJhMI48QQH3sN87YNA==}
     engines: {node: '>=10'}
     hasBin: true
 
@@ -6068,8 +5912,8 @@ packages:
     resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
     engines: {node: '>=8'}
 
-  strnum@2.2.3:
-    resolution: {integrity: sha512-oKx6RUCuHfT3oyVjtnrmn19H1SiCqgJSg+54XqURKp5aCMbrXrhLjRN9TjuwMjiYstZ0MzDrHqkGZ5dFTKd+zg==}
+  strnum@2.3.0:
+    resolution: {integrity: sha512-ums3KNd42PGyx5xaoVTO1mjU1bH3NpY4vsrVlnv9PNGqQj8wd7rJ6nEypLrJ7z5vxK5RP0yMLo6J/Gsm62DI5Q==}
 
   supports-color@2.0.0:
     resolution: {integrity: sha512-KKNVtd6pCYgPIKU4cp2733HWYCpplQhddZLBUryaAHou723x+FRzQ5Df824Fj+IyyuiQTRoub4SnIFfIcrp70g==}
@@ -6107,8 +5951,8 @@ packages:
     resolution: {integrity: sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==}
     engines: {node: '>=6'}
 
-  tar@7.5.13:
-    resolution: {integrity: sha512-tOG/7GyXpFevhXVh8jOPJrmtRpOTsYqUIkVdVooZYJS/z8WhfQUX8RJILmeuJNinGAMSu1veBr4asSHFt5/hng==}
+  tar@7.5.15:
+    resolution: {integrity: sha512-dzGK0boVlC4W5QFuQN1EFSl3bIDYsk7Tj40U6eIBnK2k/8ml7TZ5agbI5j5+qnoVcAA+rNtBml8SEiLxZpNqRQ==}
     engines: {node: '>=18'}
 
   temp-path@1.0.0:
@@ -6253,11 +6097,6 @@ packages:
     peerDependencies:
       typescript: '>=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta'
 
-  tsx@4.21.0:
-    resolution: {integrity: sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==}
-    engines: {node: '>=18.0.0'}
-    hasBin: true
-
   tty-table@4.2.3:
     resolution: {integrity: sha512-Fs15mu0vGzCrj8fmJNP7Ynxt5J7praPXqFN0leZeZBXJwkMxv9cb2D454k1ltrtUSJbZ4yH4e0CynsHLxmUfFA==}
     engines: {node: '>=8.0.0'}
@@ -6324,8 +6163,8 @@ packages:
   typedarray@0.0.6:
     resolution: {integrity: sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==}
 
-  typescript-eslint@8.59.0:
-    resolution: {integrity: sha512-BU3ONW9X+v90EcCH9ZS6LMackcVtxRLlI3XrYyqZIwVSHIk7Qf7bFw1z0M9Q0IUxhTMZCf8piY9hTYaNEIASrw==}
+  typescript-eslint@8.59.3:
+    resolution: {integrity: sha512-KgusgyDgG4LI8Ih/sWaCtZ06tckLAS5CvT5A4D1Q7bYVoAAyzwiZvE4BmwDHkhRVkvhRBepKeASoFzQetha7Fg==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     peerDependencies:
       eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
@@ -6409,12 +6248,8 @@ packages:
   util@0.12.5:
     resolution: {integrity: sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==}
 
-  uuid@8.3.2:
-    resolution: {integrity: sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==}
-    hasBin: true
-
-  uuid@9.0.1:
-    resolution: {integrity: sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==}
+  uuid@14.0.0:
+    resolution: {integrity: sha512-Qo+uWgilfSmAhXCMav1uYFynlQO7fMFiMVZsQqZRMIXp0O7rR7qjkj+cPvBHLgBqi960QCoo/PH2/6ZtVqKvrg==}
     hasBin: true
 
   v8-compile-cache-lib@3.0.1:
@@ -6534,6 +6369,10 @@ packages:
     resolution: {integrity: sha512-PSNhEJDejZYV7h50BohL09Er9VaIefr2LMAf3OEmpCkjOi34eYyQYAXUTjEQtZJTKcF0E2UKTh+osDLsgNim9Q==}
     engines: {node: '>=8'}
 
+  xml-naming@0.1.0:
+    resolution: {integrity: sha512-k8KO9hrMyNk6tUWqUfkTEZbezRRpONVOzUTnc97VnCvyj6Tf9lyUR9EDAIeiVLv56jsMcoXEwjW8Kv5yPY52lw==}
+    engines: {node: '>=16.0.0'}
+
   xmlcreate@2.0.4:
     resolution: {integrity: sha512-nquOebG4sngPmGPICTS5EnxqhKbCmz5Ox5hsszI2T6U5qdrJizBc+0ilYSEjTSzU0yZcmvppztXe/5Al5fUwdg==}
 
@@ -6648,44 +6487,44 @@ snapshots:
     dependencies:
       '@aws-crypto/sha256-browser': 5.2.0
       '@aws-crypto/sha256-js': 5.2.0
-      '@aws-sdk/core': 3.974.3
-      '@aws-sdk/credential-provider-node': 3.972.34
+      '@aws-sdk/core': 3.974.8
+      '@aws-sdk/credential-provider-node': 3.972.39
       '@aws-sdk/middleware-host-header': 3.972.10
       '@aws-sdk/middleware-logger': 3.972.10
       '@aws-sdk/middleware-recursion-detection': 3.972.11
-      '@aws-sdk/middleware-user-agent': 3.972.33
+      '@aws-sdk/middleware-user-agent': 3.972.38
       '@aws-sdk/region-config-resolver': 3.972.13
       '@aws-sdk/types': 3.973.8
       '@aws-sdk/util-endpoints': 3.996.8
       '@aws-sdk/util-user-agent-browser': 3.972.10
-      '@aws-sdk/util-user-agent-node': 3.973.19
-      '@smithy/config-resolver': 4.4.17
-      '@smithy/core': 3.23.16
-      '@smithy/fetch-http-handler': 5.3.17
-      '@smithy/hash-node': 4.2.14
-      '@smithy/invalid-dependency': 4.2.14
-      '@smithy/middleware-content-length': 4.2.14
-      '@smithy/middleware-endpoint': 4.4.31
-      '@smithy/middleware-retry': 4.5.4
-      '@smithy/middleware-serde': 4.2.19
-      '@smithy/middleware-stack': 4.2.14
-      '@smithy/node-config-provider': 4.3.14
-      '@smithy/node-http-handler': 4.6.0
-      '@smithy/protocol-http': 5.3.14
-      '@smithy/smithy-client': 4.12.12
+      '@aws-sdk/util-user-agent-node': 3.973.24
+      '@smithy/config-resolver': 4.5.1
+      '@smithy/core': 3.24.1
+      '@smithy/fetch-http-handler': 5.4.1
+      '@smithy/hash-node': 4.3.1
+      '@smithy/invalid-dependency': 4.3.1
+      '@smithy/middleware-content-length': 4.3.1
+      '@smithy/middleware-endpoint': 4.5.1
+      '@smithy/middleware-retry': 4.6.1
+      '@smithy/middleware-serde': 4.3.1
+      '@smithy/middleware-stack': 4.3.1
+      '@smithy/node-config-provider': 4.4.1
+      '@smithy/node-http-handler': 4.7.1
+      '@smithy/protocol-http': 5.4.1
+      '@smithy/smithy-client': 4.13.1
       '@smithy/types': 4.14.1
-      '@smithy/url-parser': 4.2.14
-      '@smithy/util-base64': 4.3.2
-      '@smithy/util-body-length-browser': 4.2.2
-      '@smithy/util-body-length-node': 4.2.3
-      '@smithy/util-defaults-mode-browser': 4.3.48
-      '@smithy/util-defaults-mode-node': 4.2.53
-      '@smithy/util-endpoints': 3.4.2
-      '@smithy/util-middleware': 4.2.14
-      '@smithy/util-retry': 4.3.3
-      '@smithy/util-stream': 4.5.24
-      '@smithy/util-utf8': 4.2.2
-      '@smithy/util-waiter': 4.2.16
+      '@smithy/url-parser': 4.3.1
+      '@smithy/util-base64': 4.4.1
+      '@smithy/util-body-length-browser': 4.3.1
+      '@smithy/util-body-length-node': 4.3.1
+      '@smithy/util-defaults-mode-browser': 4.4.1
+      '@smithy/util-defaults-mode-node': 4.3.1
+      '@smithy/util-endpoints': 3.5.1
+      '@smithy/util-middleware': 4.3.1
+      '@smithy/util-retry': 4.4.1
+      '@smithy/util-stream': 4.6.1
+      '@smithy/util-utf8': 4.3.1
+      '@smithy/util-waiter': 4.4.1
       tslib: 2.8.1
     transitivePeerDependencies:
       - aws-crt
@@ -6695,76 +6534,76 @@ snapshots:
       '@aws-crypto/sha1-browser': 5.2.0
       '@aws-crypto/sha256-browser': 5.2.0
       '@aws-crypto/sha256-js': 5.2.0
-      '@aws-sdk/core': 3.974.3
-      '@aws-sdk/credential-provider-node': 3.972.34
+      '@aws-sdk/core': 3.974.8
+      '@aws-sdk/credential-provider-node': 3.972.39
       '@aws-sdk/middleware-bucket-endpoint': 3.972.10
       '@aws-sdk/middleware-expect-continue': 3.972.10
-      '@aws-sdk/middleware-flexible-checksums': 3.974.11
+      '@aws-sdk/middleware-flexible-checksums': 3.974.16
       '@aws-sdk/middleware-host-header': 3.972.10
       '@aws-sdk/middleware-location-constraint': 3.972.10
       '@aws-sdk/middleware-logger': 3.972.10
       '@aws-sdk/middleware-recursion-detection': 3.972.11
-      '@aws-sdk/middleware-sdk-s3': 3.972.32
+      '@aws-sdk/middleware-sdk-s3': 3.972.37
       '@aws-sdk/middleware-ssec': 3.972.10
-      '@aws-sdk/middleware-user-agent': 3.972.33
+      '@aws-sdk/middleware-user-agent': 3.972.38
       '@aws-sdk/region-config-resolver': 3.972.13
-      '@aws-sdk/signature-v4-multi-region': 3.996.20
+      '@aws-sdk/signature-v4-multi-region': 3.996.25
       '@aws-sdk/types': 3.973.8
       '@aws-sdk/util-endpoints': 3.996.8
       '@aws-sdk/util-user-agent-browser': 3.972.10
-      '@aws-sdk/util-user-agent-node': 3.973.19
-      '@smithy/config-resolver': 4.4.17
-      '@smithy/core': 3.23.16
-      '@smithy/eventstream-serde-browser': 4.2.14
-      '@smithy/eventstream-serde-config-resolver': 4.3.14
-      '@smithy/eventstream-serde-node': 4.2.14
-      '@smithy/fetch-http-handler': 5.3.17
-      '@smithy/hash-blob-browser': 4.2.15
-      '@smithy/hash-node': 4.2.14
-      '@smithy/hash-stream-node': 4.2.14
-      '@smithy/invalid-dependency': 4.2.14
-      '@smithy/md5-js': 4.2.14
-      '@smithy/middleware-content-length': 4.2.14
-      '@smithy/middleware-endpoint': 4.4.31
-      '@smithy/middleware-retry': 4.5.4
-      '@smithy/middleware-serde': 4.2.19
-      '@smithy/middleware-stack': 4.2.14
-      '@smithy/node-config-provider': 4.3.14
-      '@smithy/node-http-handler': 4.6.0
-      '@smithy/protocol-http': 5.3.14
-      '@smithy/smithy-client': 4.12.12
+      '@aws-sdk/util-user-agent-node': 3.973.24
+      '@smithy/config-resolver': 4.5.1
+      '@smithy/core': 3.24.1
+      '@smithy/eventstream-serde-browser': 4.3.1
+      '@smithy/eventstream-serde-config-resolver': 4.4.1
+      '@smithy/eventstream-serde-node': 4.3.1
+      '@smithy/fetch-http-handler': 5.4.1
+      '@smithy/hash-blob-browser': 4.3.1
+      '@smithy/hash-node': 4.3.1
+      '@smithy/hash-stream-node': 4.3.1
+      '@smithy/invalid-dependency': 4.3.1
+      '@smithy/md5-js': 4.3.1
+      '@smithy/middleware-content-length': 4.3.1
+      '@smithy/middleware-endpoint': 4.5.1
+      '@smithy/middleware-retry': 4.6.1
+      '@smithy/middleware-serde': 4.3.1
+      '@smithy/middleware-stack': 4.3.1
+      '@smithy/node-config-provider': 4.4.1
+      '@smithy/node-http-handler': 4.7.1
+      '@smithy/protocol-http': 5.4.1
+      '@smithy/smithy-client': 4.13.1
       '@smithy/types': 4.14.1
-      '@smithy/url-parser': 4.2.14
-      '@smithy/util-base64': 4.3.2
-      '@smithy/util-body-length-browser': 4.2.2
-      '@smithy/util-body-length-node': 4.2.3
-      '@smithy/util-defaults-mode-browser': 4.3.48
-      '@smithy/util-defaults-mode-node': 4.2.53
-      '@smithy/util-endpoints': 3.4.2
-      '@smithy/util-middleware': 4.2.14
-      '@smithy/util-retry': 4.3.3
-      '@smithy/util-stream': 4.5.24
-      '@smithy/util-utf8': 4.2.2
-      '@smithy/util-waiter': 4.2.16
+      '@smithy/url-parser': 4.3.1
+      '@smithy/util-base64': 4.4.1
+      '@smithy/util-body-length-browser': 4.3.1
+      '@smithy/util-body-length-node': 4.3.1
+      '@smithy/util-defaults-mode-browser': 4.4.1
+      '@smithy/util-defaults-mode-node': 4.3.1
+      '@smithy/util-endpoints': 3.5.1
+      '@smithy/util-middleware': 4.3.1
+      '@smithy/util-retry': 4.4.1
+      '@smithy/util-stream': 4.6.1
+      '@smithy/util-utf8': 4.3.1
+      '@smithy/util-waiter': 4.4.1
       tslib: 2.8.1
     transitivePeerDependencies:
       - aws-crt
 
-  '@aws-sdk/core@3.974.3':
+  '@aws-sdk/core@3.974.8':
     dependencies:
       '@aws-sdk/types': 3.973.8
-      '@aws-sdk/xml-builder': 3.972.18
-      '@smithy/core': 3.23.16
-      '@smithy/node-config-provider': 4.3.14
-      '@smithy/property-provider': 4.2.14
-      '@smithy/protocol-http': 5.3.14
-      '@smithy/signature-v4': 5.3.14
-      '@smithy/smithy-client': 4.12.12
+      '@aws-sdk/xml-builder': 3.972.22
+      '@smithy/core': 3.24.1
+      '@smithy/node-config-provider': 4.4.1
+      '@smithy/property-provider': 4.3.1
+      '@smithy/protocol-http': 5.4.1
+      '@smithy/signature-v4': 5.4.1
+      '@smithy/smithy-client': 4.13.1
       '@smithy/types': 4.14.1
-      '@smithy/util-base64': 4.3.2
-      '@smithy/util-middleware': 4.2.14
-      '@smithy/util-retry': 4.3.3
-      '@smithy/util-utf8': 4.2.2
+      '@smithy/util-base64': 4.4.1
+      '@smithy/util-middleware': 4.3.1
+      '@smithy/util-retry': 4.4.1
+      '@smithy/util-utf8': 4.3.1
       tslib: 2.8.1
 
   '@aws-sdk/crc64-nvme@3.972.7':
@@ -6772,105 +6611,105 @@ snapshots:
       '@smithy/types': 4.14.1
       tslib: 2.8.1
 
-  '@aws-sdk/credential-provider-env@3.972.29':
+  '@aws-sdk/credential-provider-env@3.972.34':
     dependencies:
-      '@aws-sdk/core': 3.974.3
+      '@aws-sdk/core': 3.974.8
       '@aws-sdk/types': 3.973.8
-      '@smithy/property-provider': 4.2.14
+      '@smithy/property-provider': 4.3.1
       '@smithy/types': 4.14.1
       tslib: 2.8.1
 
-  '@aws-sdk/credential-provider-http@3.972.31':
+  '@aws-sdk/credential-provider-http@3.972.36':
     dependencies:
-      '@aws-sdk/core': 3.974.3
+      '@aws-sdk/core': 3.974.8
       '@aws-sdk/types': 3.973.8
-      '@smithy/fetch-http-handler': 5.3.17
-      '@smithy/node-http-handler': 4.6.0
-      '@smithy/property-provider': 4.2.14
-      '@smithy/protocol-http': 5.3.14
-      '@smithy/smithy-client': 4.12.12
+      '@smithy/fetch-http-handler': 5.4.1
+      '@smithy/node-http-handler': 4.7.1
+      '@smithy/property-provider': 4.3.1
+      '@smithy/protocol-http': 5.4.1
+      '@smithy/smithy-client': 4.13.1
       '@smithy/types': 4.14.1
-      '@smithy/util-stream': 4.5.24
+      '@smithy/util-stream': 4.6.1
       tslib: 2.8.1
 
-  '@aws-sdk/credential-provider-ini@3.972.33':
+  '@aws-sdk/credential-provider-ini@3.972.38':
     dependencies:
-      '@aws-sdk/core': 3.974.3
-      '@aws-sdk/credential-provider-env': 3.972.29
-      '@aws-sdk/credential-provider-http': 3.972.31
-      '@aws-sdk/credential-provider-login': 3.972.33
-      '@aws-sdk/credential-provider-process': 3.972.29
-      '@aws-sdk/credential-provider-sso': 3.972.33
-      '@aws-sdk/credential-provider-web-identity': 3.972.33
-      '@aws-sdk/nested-clients': 3.997.1
+      '@aws-sdk/core': 3.974.8
+      '@aws-sdk/credential-provider-env': 3.972.34
+      '@aws-sdk/credential-provider-http': 3.972.36
+      '@aws-sdk/credential-provider-login': 3.972.38
+      '@aws-sdk/credential-provider-process': 3.972.34
+      '@aws-sdk/credential-provider-sso': 3.972.38
+      '@aws-sdk/credential-provider-web-identity': 3.972.38
+      '@aws-sdk/nested-clients': 3.997.6
       '@aws-sdk/types': 3.973.8
-      '@smithy/credential-provider-imds': 4.2.14
-      '@smithy/property-provider': 4.2.14
-      '@smithy/shared-ini-file-loader': 4.4.9
+      '@smithy/credential-provider-imds': 4.3.1
+      '@smithy/property-provider': 4.3.1
+      '@smithy/shared-ini-file-loader': 4.5.1
       '@smithy/types': 4.14.1
       tslib: 2.8.1
     transitivePeerDependencies:
       - aws-crt
 
-  '@aws-sdk/credential-provider-login@3.972.33':
+  '@aws-sdk/credential-provider-login@3.972.38':
     dependencies:
-      '@aws-sdk/core': 3.974.3
-      '@aws-sdk/nested-clients': 3.997.1
+      '@aws-sdk/core': 3.974.8
+      '@aws-sdk/nested-clients': 3.997.6
       '@aws-sdk/types': 3.973.8
-      '@smithy/property-provider': 4.2.14
-      '@smithy/protocol-http': 5.3.14
-      '@smithy/shared-ini-file-loader': 4.4.9
+      '@smithy/property-provider': 4.3.1
+      '@smithy/protocol-http': 5.4.1
+      '@smithy/shared-ini-file-loader': 4.5.1
       '@smithy/types': 4.14.1
       tslib: 2.8.1
     transitivePeerDependencies:
       - aws-crt
 
-  '@aws-sdk/credential-provider-node@3.972.34':
+  '@aws-sdk/credential-provider-node@3.972.39':
     dependencies:
-      '@aws-sdk/credential-provider-env': 3.972.29
-      '@aws-sdk/credential-provider-http': 3.972.31
-      '@aws-sdk/credential-provider-ini': 3.972.33
-      '@aws-sdk/credential-provider-process': 3.972.29
-      '@aws-sdk/credential-provider-sso': 3.972.33
-      '@aws-sdk/credential-provider-web-identity': 3.972.33
+      '@aws-sdk/credential-provider-env': 3.972.34
+      '@aws-sdk/credential-provider-http': 3.972.36
+      '@aws-sdk/credential-provider-ini': 3.972.38
+      '@aws-sdk/credential-provider-process': 3.972.34
+      '@aws-sdk/credential-provider-sso': 3.972.38
+      '@aws-sdk/credential-provider-web-identity': 3.972.38
       '@aws-sdk/types': 3.973.8
-      '@smithy/credential-provider-imds': 4.2.14
-      '@smithy/property-provider': 4.2.14
-      '@smithy/shared-ini-file-loader': 4.4.9
+      '@smithy/credential-provider-imds': 4.3.1
+      '@smithy/property-provider': 4.3.1
+      '@smithy/shared-ini-file-loader': 4.5.1
       '@smithy/types': 4.14.1
       tslib: 2.8.1
     transitivePeerDependencies:
       - aws-crt
 
-  '@aws-sdk/credential-provider-process@3.972.29':
+  '@aws-sdk/credential-provider-process@3.972.34':
     dependencies:
-      '@aws-sdk/core': 3.974.3
+      '@aws-sdk/core': 3.974.8
       '@aws-sdk/types': 3.973.8
-      '@smithy/property-provider': 4.2.14
-      '@smithy/shared-ini-file-loader': 4.4.9
+      '@smithy/property-provider': 4.3.1
+      '@smithy/shared-ini-file-loader': 4.5.1
       '@smithy/types': 4.14.1
       tslib: 2.8.1
 
-  '@aws-sdk/credential-provider-sso@3.972.33':
+  '@aws-sdk/credential-provider-sso@3.972.38':
     dependencies:
-      '@aws-sdk/core': 3.974.3
-      '@aws-sdk/nested-clients': 3.997.1
-      '@aws-sdk/token-providers': 3.1034.0
+      '@aws-sdk/core': 3.974.8
+      '@aws-sdk/nested-clients': 3.997.6
+      '@aws-sdk/token-providers': 3.1041.0
       '@aws-sdk/types': 3.973.8
-      '@smithy/property-provider': 4.2.14
-      '@smithy/shared-ini-file-loader': 4.4.9
+      '@smithy/property-provider': 4.3.1
+      '@smithy/shared-ini-file-loader': 4.5.1
       '@smithy/types': 4.14.1
       tslib: 2.8.1
     transitivePeerDependencies:
       - aws-crt
 
-  '@aws-sdk/credential-provider-web-identity@3.972.33':
+  '@aws-sdk/credential-provider-web-identity@3.972.38':
     dependencies:
-      '@aws-sdk/core': 3.974.3
-      '@aws-sdk/nested-clients': 3.997.1
+      '@aws-sdk/core': 3.974.8
+      '@aws-sdk/nested-clients': 3.997.6
       '@aws-sdk/types': 3.973.8
-      '@smithy/property-provider': 4.2.14
-      '@smithy/shared-ini-file-loader': 4.4.9
+      '@smithy/property-provider': 4.3.1
+      '@smithy/shared-ini-file-loader': 4.5.1
       '@smithy/types': 4.14.1
       tslib: 2.8.1
     transitivePeerDependencies:
@@ -6880,40 +6719,40 @@ snapshots:
     dependencies:
       '@aws-sdk/types': 3.973.8
       '@aws-sdk/util-arn-parser': 3.972.3
-      '@smithy/node-config-provider': 4.3.14
-      '@smithy/protocol-http': 5.3.14
+      '@smithy/node-config-provider': 4.4.1
+      '@smithy/protocol-http': 5.4.1
       '@smithy/types': 4.14.1
-      '@smithy/util-config-provider': 4.2.2
+      '@smithy/util-config-provider': 4.3.1
       tslib: 2.8.1
 
   '@aws-sdk/middleware-expect-continue@3.972.10':
     dependencies:
       '@aws-sdk/types': 3.973.8
-      '@smithy/protocol-http': 5.3.14
+      '@smithy/protocol-http': 5.4.1
       '@smithy/types': 4.14.1
       tslib: 2.8.1
 
-  '@aws-sdk/middleware-flexible-checksums@3.974.11':
+  '@aws-sdk/middleware-flexible-checksums@3.974.16':
     dependencies:
       '@aws-crypto/crc32': 5.2.0
       '@aws-crypto/crc32c': 5.2.0
       '@aws-crypto/util': 5.2.0
-      '@aws-sdk/core': 3.974.3
+      '@aws-sdk/core': 3.974.8
       '@aws-sdk/crc64-nvme': 3.972.7
       '@aws-sdk/types': 3.973.8
-      '@smithy/is-array-buffer': 4.2.2
-      '@smithy/node-config-provider': 4.3.14
-      '@smithy/protocol-http': 5.3.14
+      '@smithy/is-array-buffer': 4.3.1
+      '@smithy/node-config-provider': 4.4.1
+      '@smithy/protocol-http': 5.4.1
       '@smithy/types': 4.14.1
-      '@smithy/util-middleware': 4.2.14
-      '@smithy/util-stream': 4.5.24
-      '@smithy/util-utf8': 4.2.2
+      '@smithy/util-middleware': 4.3.1
+      '@smithy/util-stream': 4.6.1
+      '@smithy/util-utf8': 4.3.1
       tslib: 2.8.1
 
   '@aws-sdk/middleware-host-header@3.972.10':
     dependencies:
       '@aws-sdk/types': 3.973.8
-      '@smithy/protocol-http': 5.3.14
+      '@smithy/protocol-http': 5.4.1
       '@smithy/types': 4.14.1
       tslib: 2.8.1
 
@@ -6933,25 +6772,25 @@ snapshots:
     dependencies:
       '@aws-sdk/types': 3.973.8
       '@aws/lambda-invoke-store': 0.2.4
-      '@smithy/protocol-http': 5.3.14
+      '@smithy/protocol-http': 5.4.1
       '@smithy/types': 4.14.1
       tslib: 2.8.1
 
-  '@aws-sdk/middleware-sdk-s3@3.972.32':
+  '@aws-sdk/middleware-sdk-s3@3.972.37':
     dependencies:
-      '@aws-sdk/core': 3.974.3
+      '@aws-sdk/core': 3.974.8
       '@aws-sdk/types': 3.973.8
       '@aws-sdk/util-arn-parser': 3.972.3
-      '@smithy/core': 3.23.16
-      '@smithy/node-config-provider': 4.3.14
-      '@smithy/protocol-http': 5.3.14
-      '@smithy/signature-v4': 5.3.14
-      '@smithy/smithy-client': 4.12.12
+      '@smithy/core': 3.24.1
+      '@smithy/node-config-provider': 4.4.1
+      '@smithy/protocol-http': 5.4.1
+      '@smithy/signature-v4': 5.4.1
+      '@smithy/smithy-client': 4.13.1
       '@smithy/types': 4.14.1
-      '@smithy/util-config-provider': 4.2.2
-      '@smithy/util-middleware': 4.2.14
-      '@smithy/util-stream': 4.5.24
-      '@smithy/util-utf8': 4.2.2
+      '@smithy/util-config-provider': 4.3.1
+      '@smithy/util-middleware': 4.3.1
+      '@smithy/util-stream': 4.6.1
+      '@smithy/util-utf8': 4.3.1
       tslib: 2.8.1
 
   '@aws-sdk/middleware-ssec@3.972.10':
@@ -6960,57 +6799,57 @@ snapshots:
       '@smithy/types': 4.14.1
       tslib: 2.8.1
 
-  '@aws-sdk/middleware-user-agent@3.972.33':
+  '@aws-sdk/middleware-user-agent@3.972.38':
     dependencies:
-      '@aws-sdk/core': 3.974.3
+      '@aws-sdk/core': 3.974.8
       '@aws-sdk/types': 3.973.8
       '@aws-sdk/util-endpoints': 3.996.8
-      '@smithy/core': 3.23.16
-      '@smithy/protocol-http': 5.3.14
+      '@smithy/core': 3.24.1
+      '@smithy/protocol-http': 5.4.1
       '@smithy/types': 4.14.1
-      '@smithy/util-retry': 4.3.3
+      '@smithy/util-retry': 4.4.1
       tslib: 2.8.1
 
-  '@aws-sdk/nested-clients@3.997.1':
+  '@aws-sdk/nested-clients@3.997.6':
     dependencies:
       '@aws-crypto/sha256-browser': 5.2.0
       '@aws-crypto/sha256-js': 5.2.0
-      '@aws-sdk/core': 3.974.3
+      '@aws-sdk/core': 3.974.8
       '@aws-sdk/middleware-host-header': 3.972.10
       '@aws-sdk/middleware-logger': 3.972.10
       '@aws-sdk/middleware-recursion-detection': 3.972.11
-      '@aws-sdk/middleware-user-agent': 3.972.33
+      '@aws-sdk/middleware-user-agent': 3.972.38
       '@aws-sdk/region-config-resolver': 3.972.13
-      '@aws-sdk/signature-v4-multi-region': 3.996.20
+      '@aws-sdk/signature-v4-multi-region': 3.996.25
       '@aws-sdk/types': 3.973.8
       '@aws-sdk/util-endpoints': 3.996.8
       '@aws-sdk/util-user-agent-browser': 3.972.10
-      '@aws-sdk/util-user-agent-node': 3.973.19
-      '@smithy/config-resolver': 4.4.17
-      '@smithy/core': 3.23.16
-      '@smithy/fetch-http-handler': 5.3.17
-      '@smithy/hash-node': 4.2.14
-      '@smithy/invalid-dependency': 4.2.14
-      '@smithy/middleware-content-length': 4.2.14
-      '@smithy/middleware-endpoint': 4.4.31
-      '@smithy/middleware-retry': 4.5.4
-      '@smithy/middleware-serde': 4.2.19
-      '@smithy/middleware-stack': 4.2.14
-      '@smithy/node-config-provider': 4.3.14
-      '@smithy/node-http-handler': 4.6.0
-      '@smithy/protocol-http': 5.3.14
-      '@smithy/smithy-client': 4.12.12
+      '@aws-sdk/util-user-agent-node': 3.973.24
+      '@smithy/config-resolver': 4.5.1
+      '@smithy/core': 3.24.1
+      '@smithy/fetch-http-handler': 5.4.1
+      '@smithy/hash-node': 4.3.1
+      '@smithy/invalid-dependency': 4.3.1
+      '@smithy/middleware-content-length': 4.3.1
+      '@smithy/middleware-endpoint': 4.5.1
+      '@smithy/middleware-retry': 4.6.1
+      '@smithy/middleware-serde': 4.3.1
+      '@smithy/middleware-stack': 4.3.1
+      '@smithy/node-config-provider': 4.4.1
+      '@smithy/node-http-handler': 4.7.1
+      '@smithy/protocol-http': 5.4.1
+      '@smithy/smithy-client': 4.13.1
       '@smithy/types': 4.14.1
-      '@smithy/url-parser': 4.2.14
-      '@smithy/util-base64': 4.3.2
-      '@smithy/util-body-length-browser': 4.2.2
-      '@smithy/util-body-length-node': 4.2.3
-      '@smithy/util-defaults-mode-browser': 4.3.48
-      '@smithy/util-defaults-mode-node': 4.2.53
-      '@smithy/util-endpoints': 3.4.2
-      '@smithy/util-middleware': 4.2.14
-      '@smithy/util-retry': 4.3.3
-      '@smithy/util-utf8': 4.2.2
+      '@smithy/url-parser': 4.3.1
+      '@smithy/util-base64': 4.4.1
+      '@smithy/util-body-length-browser': 4.3.1
+      '@smithy/util-body-length-node': 4.3.1
+      '@smithy/util-defaults-mode-browser': 4.4.1
+      '@smithy/util-defaults-mode-node': 4.3.1
+      '@smithy/util-endpoints': 3.5.1
+      '@smithy/util-middleware': 4.3.1
+      '@smithy/util-retry': 4.4.1
+      '@smithy/util-utf8': 4.3.1
       tslib: 2.8.1
     transitivePeerDependencies:
       - aws-crt
@@ -7018,27 +6857,27 @@ snapshots:
   '@aws-sdk/region-config-resolver@3.972.13':
     dependencies:
       '@aws-sdk/types': 3.973.8
-      '@smithy/config-resolver': 4.4.17
-      '@smithy/node-config-provider': 4.3.14
+      '@smithy/config-resolver': 4.5.1
+      '@smithy/node-config-provider': 4.4.1
       '@smithy/types': 4.14.1
       tslib: 2.8.1
 
-  '@aws-sdk/signature-v4-multi-region@3.996.20':
+  '@aws-sdk/signature-v4-multi-region@3.996.25':
     dependencies:
-      '@aws-sdk/middleware-sdk-s3': 3.972.32
+      '@aws-sdk/middleware-sdk-s3': 3.972.37
       '@aws-sdk/types': 3.973.8
-      '@smithy/protocol-http': 5.3.14
-      '@smithy/signature-v4': 5.3.14
+      '@smithy/protocol-http': 5.4.1
+      '@smithy/signature-v4': 5.4.1
       '@smithy/types': 4.14.1
       tslib: 2.8.1
 
-  '@aws-sdk/token-providers@3.1034.0':
+  '@aws-sdk/token-providers@3.1041.0':
     dependencies:
-      '@aws-sdk/core': 3.974.3
-      '@aws-sdk/nested-clients': 3.997.1
+      '@aws-sdk/core': 3.974.8
+      '@aws-sdk/nested-clients': 3.997.6
       '@aws-sdk/types': 3.973.8
-      '@smithy/property-provider': 4.2.14
-      '@smithy/shared-ini-file-loader': 4.4.9
+      '@smithy/property-provider': 4.3.1
+      '@smithy/shared-ini-file-loader': 4.5.1
       '@smithy/types': 4.14.1
       tslib: 2.8.1
     transitivePeerDependencies:
@@ -7057,8 +6896,8 @@ snapshots:
     dependencies:
       '@aws-sdk/types': 3.973.8
       '@smithy/types': 4.14.1
-      '@smithy/url-parser': 4.2.14
-      '@smithy/util-endpoints': 3.4.2
+      '@smithy/url-parser': 4.3.1
+      '@smithy/util-endpoints': 3.5.1
       tslib: 2.8.1
 
   '@aws-sdk/util-locate-window@3.965.5':
@@ -7072,19 +6911,20 @@ snapshots:
       bowser: 2.14.1
       tslib: 2.8.1
 
-  '@aws-sdk/util-user-agent-node@3.973.19':
+  '@aws-sdk/util-user-agent-node@3.973.24':
     dependencies:
-      '@aws-sdk/middleware-user-agent': 3.972.33
+      '@aws-sdk/middleware-user-agent': 3.972.38
       '@aws-sdk/types': 3.973.8
-      '@smithy/node-config-provider': 4.3.14
+      '@smithy/node-config-provider': 4.4.1
       '@smithy/types': 4.14.1
-      '@smithy/util-config-provider': 4.2.2
+      '@smithy/util-config-provider': 4.3.1
       tslib: 2.8.1
 
-  '@aws-sdk/xml-builder@3.972.18':
+  '@aws-sdk/xml-builder@3.972.22':
     dependencies:
+      '@nodable/entities': 2.1.0
       '@smithy/types': 4.14.1
-      fast-xml-parser: 5.5.8
+      fast-xml-parser: 5.7.2
       tslib: 2.8.1
 
   '@aws/lambda-invoke-store@0.2.4': {}
@@ -7095,7 +6935,7 @@ snapshots:
       js-tokens: 4.0.0
       picocolors: 1.1.1
 
-  '@babel/compat-data@7.29.0': {}
+  '@babel/compat-data@7.29.3': {}
 
   '@babel/core@7.29.0':
     dependencies:
@@ -7104,7 +6944,7 @@ snapshots:
       '@babel/helper-compilation-targets': 7.28.6
       '@babel/helper-module-transforms': 7.28.6(@babel/core@7.29.0)
       '@babel/helpers': 7.29.2
-      '@babel/parser': 7.29.2
+      '@babel/parser': 7.29.3
       '@babel/template': 7.28.6
       '@babel/traverse': 7.29.0
       '@babel/types': 7.29.0
@@ -7119,7 +6959,7 @@ snapshots:
 
   '@babel/generator@7.29.1':
     dependencies:
-      '@babel/parser': 7.29.2
+      '@babel/parser': 7.29.3
       '@babel/types': 7.29.0
       '@jridgewell/gen-mapping': 0.3.13
       '@jridgewell/trace-mapping': 0.3.31
@@ -7127,7 +6967,7 @@ snapshots:
 
   '@babel/helper-compilation-targets@7.28.6':
     dependencies:
-      '@babel/compat-data': 7.29.0
+      '@babel/compat-data': 7.29.3
       '@babel/helper-validator-option': 7.27.1
       browserslist: 4.28.2
       lru-cache: 5.1.1
@@ -7164,7 +7004,7 @@ snapshots:
       '@babel/template': 7.28.6
       '@babel/types': 7.29.0
 
-  '@babel/parser@7.29.2':
+  '@babel/parser@7.29.3':
     dependencies:
       '@babel/types': 7.29.0
 
@@ -7256,7 +7096,7 @@ snapshots:
   '@babel/template@7.28.6':
     dependencies:
       '@babel/code-frame': 7.29.0
-      '@babel/parser': 7.29.2
+      '@babel/parser': 7.29.3
       '@babel/types': 7.29.0
 
   '@babel/traverse@7.29.0':
@@ -7264,7 +7104,7 @@ snapshots:
       '@babel/code-frame': 7.29.0
       '@babel/generator': 7.29.1
       '@babel/helper-globals': 7.28.0
-      '@babel/parser': 7.29.2
+      '@babel/parser': 7.29.3
       '@babel/template': 7.28.6
       '@babel/types': 7.29.0
       debug: 4.4.3(supports-color@8.1.1)
@@ -7282,12 +7122,12 @@ snapshots:
 
   '@colors/colors@1.6.0': {}
 
-  '@contentstack/cli-auth@2.0.0-beta.11(@types/node@22.19.17)':
+  '@contentstack/cli-auth@2.0.0-beta.11(@types/node@22.19.19)':
     dependencies:
-      '@contentstack/cli-command': 2.0.0-beta.6(@types/node@22.19.17)
-      '@contentstack/cli-utilities': 2.0.0-beta.7(@types/node@22.19.17)
-      '@oclif/core': 4.10.5
-      '@oclif/plugin-help': 6.2.44
+      '@contentstack/cli-command': 2.0.0-beta.6(@types/node@22.19.19)
+      '@contentstack/cli-utilities': 2.0.0-beta.7(@types/node@22.19.19)
+      '@oclif/core': 4.11.2
+      '@oclif/plugin-help': 6.2.48
       otplib: 12.0.1
     transitivePeerDependencies:
       - '@types/node'
@@ -7296,8 +7136,8 @@ snapshots:
   '@contentstack/cli-command@2.0.0-beta.6(@types/node@14.18.63)':
     dependencies:
       '@contentstack/cli-utilities': 2.0.0-beta.7(@types/node@14.18.63)
-      '@oclif/core': 4.10.5
-      '@oclif/plugin-help': 6.2.44
+      '@oclif/core': 4.11.2
+      '@oclif/plugin-help': 6.2.48
       contentstack: 3.27.0
     transitivePeerDependencies:
       - '@types/node'
@@ -7306,8 +7146,8 @@ snapshots:
   '@contentstack/cli-command@2.0.0-beta.6(@types/node@14.18.63)(debug@4.4.3)':
     dependencies:
       '@contentstack/cli-utilities': 2.0.0-beta.7(@types/node@14.18.63)(debug@4.4.3)
-      '@oclif/core': 4.10.5
-      '@oclif/plugin-help': 6.2.44
+      '@oclif/core': 4.11.2
+      '@oclif/plugin-help': 6.2.48
       contentstack: 3.27.0
     transitivePeerDependencies:
       - '@types/node'
@@ -7316,28 +7156,28 @@ snapshots:
   '@contentstack/cli-command@2.0.0-beta.6(@types/node@18.19.130)':
     dependencies:
       '@contentstack/cli-utilities': 2.0.0-beta.7(@types/node@18.19.130)
-      '@oclif/core': 4.10.5
-      '@oclif/plugin-help': 6.2.44
+      '@oclif/core': 4.11.2
+      '@oclif/plugin-help': 6.2.48
       contentstack: 3.27.0
     transitivePeerDependencies:
       - '@types/node'
       - debug
 
-  '@contentstack/cli-command@2.0.0-beta.6(@types/node@20.19.39)':
+  '@contentstack/cli-command@2.0.0-beta.6(@types/node@20.19.41)':
     dependencies:
-      '@contentstack/cli-utilities': 2.0.0-beta.7(@types/node@20.19.39)
-      '@oclif/core': 4.10.5
-      '@oclif/plugin-help': 6.2.44
+      '@contentstack/cli-utilities': 2.0.0-beta.7(@types/node@20.19.41)
+      '@oclif/core': 4.11.2
+      '@oclif/plugin-help': 6.2.48
       contentstack: 3.27.0
     transitivePeerDependencies:
       - '@types/node'
       - debug
 
-  '@contentstack/cli-command@2.0.0-beta.6(@types/node@22.19.17)':
+  '@contentstack/cli-command@2.0.0-beta.6(@types/node@22.19.19)':
     dependencies:
-      '@contentstack/cli-utilities': 2.0.0-beta.7(@types/node@22.19.17)
-      '@oclif/core': 4.10.5
-      '@oclif/plugin-help': 6.2.44
+      '@contentstack/cli-utilities': 2.0.0-beta.7(@types/node@22.19.19)
+      '@oclif/core': 4.11.2
+      '@oclif/plugin-help': 6.2.48
       contentstack: 3.27.0
     transitivePeerDependencies:
       - '@types/node'
@@ -7348,29 +7188,38 @@ snapshots:
       '@contentstack/cli-command': 2.0.0-beta.6(@types/node@18.19.130)
       '@contentstack/cli-utilities': 2.0.0-beta.7(@types/node@18.19.130)
       '@contentstack/utils': 1.9.1
-      '@oclif/core': 4.10.5
-      '@oclif/plugin-help': 6.2.44
+      '@oclif/core': 4.11.2
+      '@oclif/plugin-help': 6.2.48
       lodash: 4.18.1
     transitivePeerDependencies:
       - '@types/node'
       - debug
 
-  '@contentstack/cli-config@2.0.0-beta.8(@types/node@22.19.17)':
+  '@contentstack/cli-config@2.0.0-beta.8(@types/node@22.19.19)':
     dependencies:
-      '@contentstack/cli-command': 2.0.0-beta.6(@types/node@22.19.17)
-      '@contentstack/cli-utilities': 2.0.0-beta.7(@types/node@22.19.17)
+      '@contentstack/cli-command': 2.0.0-beta.6(@types/node@22.19.19)
+      '@contentstack/cli-utilities': 2.0.0-beta.7(@types/node@22.19.19)
       '@contentstack/utils': 1.9.1
-      '@oclif/core': 4.10.5
-      '@oclif/plugin-help': 6.2.44
+      '@oclif/core': 4.11.2
+      '@oclif/plugin-help': 6.2.48
       lodash: 4.18.1
     transitivePeerDependencies:
       - '@types/node'
       - debug
 
+  '@contentstack/cli-dev-dependencies@1.3.1':
+    dependencies:
+      '@oclif/core': 4.11.2
+      '@oclif/test': 4.1.18(@oclif/core@4.11.2)
+      fancy-test: 2.0.42
+      lodash: 4.18.1
+    transitivePeerDependencies:
+      - supports-color
+
   '@contentstack/cli-dev-dependencies@2.0.0-beta.0':
     dependencies:
-      '@oclif/core': 4.10.5
-      '@oclif/test': 4.1.18(@oclif/core@4.10.5)
+      '@oclif/core': 4.11.2
+      '@oclif/test': 4.1.18(@oclif/core@4.11.2)
       fancy-test: 2.0.42
       lodash: 4.18.1
     transitivePeerDependencies:
@@ -7378,9 +7227,9 @@ snapshots:
 
   '@contentstack/cli-utilities@2.0.0-beta.7(@types/node@14.18.63)':
     dependencies:
-      '@contentstack/management': 1.30.1(debug@4.4.3)
-      '@contentstack/marketplace-sdk': 1.5.1(debug@4.4.3)
-      '@oclif/core': 4.10.5
+      '@contentstack/management': 1.30.2(debug@4.4.3)
+      '@contentstack/marketplace-sdk': 1.5.2(debug@4.4.3)
+      '@oclif/core': 4.11.2
       axios: 1.15.2(debug@4.4.3)
       chalk: 5.6.2
       cli-cursor: 3.1.0
@@ -7404,7 +7253,7 @@ snapshots:
       traverse: 0.6.11
       tty-table: 4.2.3
       unique-string: 2.0.0
-      uuid: 9.0.1
+      uuid: 14.0.0
       winston: 3.19.0
       xdg-basedir: 4.0.0
     transitivePeerDependencies:
@@ -7413,9 +7262,9 @@ snapshots:
 
   '@contentstack/cli-utilities@2.0.0-beta.7(@types/node@14.18.63)(debug@4.4.3)':
     dependencies:
-      '@contentstack/management': 1.30.1(debug@4.4.3)
-      '@contentstack/marketplace-sdk': 1.5.1(debug@4.4.3)
-      '@oclif/core': 4.10.5
+      '@contentstack/management': 1.30.2(debug@4.4.3)
+      '@contentstack/marketplace-sdk': 1.5.2(debug@4.4.3)
+      '@oclif/core': 4.11.2
       axios: 1.15.2(debug@4.4.3)
       chalk: 5.6.2
       cli-cursor: 3.1.0
@@ -7439,7 +7288,7 @@ snapshots:
       traverse: 0.6.11
       tty-table: 4.2.3
       unique-string: 2.0.0
-      uuid: 9.0.1
+      uuid: 14.0.0
       winston: 3.19.0
       xdg-basedir: 4.0.0
     transitivePeerDependencies:
@@ -7448,9 +7297,9 @@ snapshots:
 
   '@contentstack/cli-utilities@2.0.0-beta.7(@types/node@18.19.130)':
     dependencies:
-      '@contentstack/management': 1.30.1(debug@4.4.3)
-      '@contentstack/marketplace-sdk': 1.5.1(debug@4.4.3)
-      '@oclif/core': 4.10.5
+      '@contentstack/management': 1.30.2(debug@4.4.3)
+      '@contentstack/marketplace-sdk': 1.5.2(debug@4.4.3)
+      '@oclif/core': 4.11.2
       axios: 1.15.2(debug@4.4.3)
       chalk: 5.6.2
       cli-cursor: 3.1.0
@@ -7474,18 +7323,18 @@ snapshots:
       traverse: 0.6.11
       tty-table: 4.2.3
       unique-string: 2.0.0
-      uuid: 9.0.1
+      uuid: 14.0.0
       winston: 3.19.0
       xdg-basedir: 4.0.0
     transitivePeerDependencies:
       - '@types/node'
       - debug
 
-  '@contentstack/cli-utilities@2.0.0-beta.7(@types/node@20.19.39)':
+  '@contentstack/cli-utilities@2.0.0-beta.7(@types/node@20.19.41)':
     dependencies:
-      '@contentstack/management': 1.30.1(debug@4.4.3)
-      '@contentstack/marketplace-sdk': 1.5.1(debug@4.4.3)
-      '@oclif/core': 4.10.5
+      '@contentstack/management': 1.30.2(debug@4.4.3)
+      '@contentstack/marketplace-sdk': 1.5.2(debug@4.4.3)
+      '@oclif/core': 4.11.2
       axios: 1.15.2(debug@4.4.3)
       chalk: 5.6.2
       cli-cursor: 3.1.0
@@ -7494,7 +7343,7 @@ snapshots:
       conf: 10.2.0
       dotenv: 16.6.1
       figures: 3.2.0
-      inquirer: 12.11.1(@types/node@20.19.39)
+      inquirer: 12.11.1(@types/node@20.19.41)
       inquirer-search-checkbox: 1.0.0
       inquirer-search-list: 1.2.6
       js-yaml: 4.1.1
@@ -7509,18 +7358,18 @@ snapshots:
       traverse: 0.6.11
       tty-table: 4.2.3
       unique-string: 2.0.0
-      uuid: 9.0.1
+      uuid: 14.0.0
       winston: 3.19.0
       xdg-basedir: 4.0.0
     transitivePeerDependencies:
       - '@types/node'
       - debug
 
-  '@contentstack/cli-utilities@2.0.0-beta.7(@types/node@22.19.17)':
+  '@contentstack/cli-utilities@2.0.0-beta.7(@types/node@22.19.19)':
     dependencies:
-      '@contentstack/management': 1.30.1(debug@4.4.3)
-      '@contentstack/marketplace-sdk': 1.5.1(debug@4.4.3)
-      '@oclif/core': 4.10.5
+      '@contentstack/management': 1.30.2(debug@4.4.3)
+      '@contentstack/marketplace-sdk': 1.5.2(debug@4.4.3)
+      '@oclif/core': 4.11.2
       axios: 1.15.2(debug@4.4.3)
       chalk: 5.6.2
       cli-cursor: 3.1.0
@@ -7529,7 +7378,7 @@ snapshots:
       conf: 10.2.0
       dotenv: 16.6.1
       figures: 3.2.0
-      inquirer: 12.11.1(@types/node@22.19.17)
+      inquirer: 12.11.1(@types/node@22.19.19)
       inquirer-search-checkbox: 1.0.0
       inquirer-search-list: 1.2.6
       js-yaml: 4.1.1
@@ -7544,14 +7393,14 @@ snapshots:
       traverse: 0.6.11
       tty-table: 4.2.3
       unique-string: 2.0.0
-      uuid: 9.0.1
+      uuid: 14.0.0
       winston: 3.19.0
       xdg-basedir: 4.0.0
     transitivePeerDependencies:
       - '@types/node'
       - debug
 
-  '@contentstack/management@1.30.1(debug@4.4.3)':
+  '@contentstack/management@1.30.2(debug@4.4.3)':
     dependencies:
       '@contentstack/utils': 1.9.1
       assert: 2.1.0
@@ -7566,7 +7415,7 @@ snapshots:
     transitivePeerDependencies:
       - debug
 
-  '@contentstack/marketplace-sdk@1.5.1(debug@4.4.3)':
+  '@contentstack/marketplace-sdk@1.5.2(debug@4.4.3)':
     dependencies:
       '@contentstack/utils': 1.9.1
       axios: 1.15.2(debug@4.4.3)
@@ -7580,112 +7429,34 @@ snapshots:
       '@jridgewell/trace-mapping': 0.3.9
 
   '@dabh/diagnostics@2.0.8':
-    dependencies:
-      '@so-ric/colorspace': 1.1.6
-      enabled: 2.0.0
-      kuler: 2.0.0
-
-  '@emnapi/core@1.10.0':
-    dependencies:
-      '@emnapi/wasi-threads': 1.2.1
-      tslib: 2.8.1
-    optional: true
-
-  '@emnapi/runtime@1.10.0':
-    dependencies:
-      tslib: 2.8.1
-    optional: true
-
-  '@emnapi/wasi-threads@1.2.1':
-    dependencies:
-      tslib: 2.8.1
-    optional: true
-
-  '@es-joy/jsdoccomment@0.50.2':
-    dependencies:
-      '@types/estree': 1.0.8
-      '@typescript-eslint/types': 8.59.0
-      comment-parser: 1.4.1
-      esquery: 1.7.0
-      jsdoc-type-pratt-parser: 4.1.0
-
-  '@esbuild/aix-ppc64@0.27.7':
-    optional: true
-
-  '@esbuild/android-arm64@0.27.7':
-    optional: true
-
-  '@esbuild/android-arm@0.27.7':
-    optional: true
-
-  '@esbuild/android-x64@0.27.7':
-    optional: true
-
-  '@esbuild/darwin-arm64@0.27.7':
-    optional: true
-
-  '@esbuild/darwin-x64@0.27.7':
-    optional: true
-
-  '@esbuild/freebsd-arm64@0.27.7':
-    optional: true
-
-  '@esbuild/freebsd-x64@0.27.7':
-    optional: true
-
-  '@esbuild/linux-arm64@0.27.7':
-    optional: true
-
-  '@esbuild/linux-arm@0.27.7':
-    optional: true
-
-  '@esbuild/linux-ia32@0.27.7':
-    optional: true
-
-  '@esbuild/linux-loong64@0.27.7':
-    optional: true
-
-  '@esbuild/linux-mips64el@0.27.7':
-    optional: true
-
-  '@esbuild/linux-ppc64@0.27.7':
-    optional: true
-
-  '@esbuild/linux-riscv64@0.27.7':
-    optional: true
-
-  '@esbuild/linux-s390x@0.27.7':
-    optional: true
-
-  '@esbuild/linux-x64@0.27.7':
-    optional: true
-
-  '@esbuild/netbsd-arm64@0.27.7':
-    optional: true
-
-  '@esbuild/netbsd-x64@0.27.7':
-    optional: true
-
-  '@esbuild/openbsd-arm64@0.27.7':
-    optional: true
-
-  '@esbuild/openbsd-x64@0.27.7':
-    optional: true
-
-  '@esbuild/openharmony-arm64@0.27.7':
-    optional: true
+    dependencies:
+      '@so-ric/colorspace': 1.1.6
+      enabled: 2.0.0
+      kuler: 2.0.0
 
-  '@esbuild/sunos-x64@0.27.7':
+  '@emnapi/core@1.10.0':
+    dependencies:
+      '@emnapi/wasi-threads': 1.2.1
+      tslib: 2.8.1
     optional: true
 
-  '@esbuild/win32-arm64@0.27.7':
+  '@emnapi/runtime@1.10.0':
+    dependencies:
+      tslib: 2.8.1
     optional: true
 
-  '@esbuild/win32-ia32@0.27.7':
+  '@emnapi/wasi-threads@1.2.1':
+    dependencies:
+      tslib: 2.8.1
     optional: true
 
-  '@esbuild/win32-x64@0.27.7':
-    optional: true
+  '@es-joy/jsdoccomment@0.50.2':
+    dependencies:
+      '@types/estree': 1.0.9
+      '@typescript-eslint/types': 8.59.3
+      comment-parser: 1.4.1
+      esquery: 1.7.0
+      jsdoc-type-pratt-parser: 4.1.0
 
   '@eslint-community/eslint-utils@4.9.1(eslint@8.57.1)':
     dependencies:
@@ -7705,6 +7476,12 @@ snapshots:
     optionalDependencies:
       eslint: 8.57.1
 
+  '@eslint/compat@1.4.1(eslint@9.39.4)':
+    dependencies:
+      '@eslint/core': 0.17.0
+    optionalDependencies:
+      eslint: 9.39.4
+
   '@eslint/config-array@0.21.2':
     dependencies:
       '@eslint/object-schema': 2.1.7
@@ -7742,7 +7519,7 @@ snapshots:
 
   '@eslint/eslintrc@2.1.4':
     dependencies:
-      ajv: 6.14.0
+      ajv: 6.15.0
       debug: 4.4.3(supports-color@8.1.1)
       espree: 9.6.1
       globals: 13.24.0
@@ -7756,7 +7533,7 @@ snapshots:
 
   '@eslint/eslintrc@3.3.5':
     dependencies:
-      ajv: 6.14.0
+      ajv: 6.15.0
       debug: 4.4.3(supports-color@8.1.1)
       espree: 10.4.0
       globals: 14.0.0
@@ -7860,25 +7637,25 @@ snapshots:
     optionalDependencies:
       '@types/node': 18.19.130
 
-  '@inquirer/checkbox@4.3.2(@types/node@20.19.39)':
+  '@inquirer/checkbox@4.3.2(@types/node@20.19.41)':
     dependencies:
       '@inquirer/ansi': 1.0.2
-      '@inquirer/core': 10.3.2(@types/node@20.19.39)
+      '@inquirer/core': 10.3.2(@types/node@20.19.41)
       '@inquirer/figures': 1.0.15
-      '@inquirer/type': 3.0.10(@types/node@20.19.39)
+      '@inquirer/type': 3.0.10(@types/node@20.19.41)
       yoctocolors-cjs: 2.1.3
     optionalDependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
-  '@inquirer/checkbox@4.3.2(@types/node@22.19.17)':
+  '@inquirer/checkbox@4.3.2(@types/node@22.19.19)':
     dependencies:
       '@inquirer/ansi': 1.0.2
-      '@inquirer/core': 10.3.2(@types/node@22.19.17)
+      '@inquirer/core': 10.3.2(@types/node@22.19.19)
       '@inquirer/figures': 1.0.15
-      '@inquirer/type': 3.0.10(@types/node@22.19.17)
+      '@inquirer/type': 3.0.10(@types/node@22.19.19)
       yoctocolors-cjs: 2.1.3
     optionalDependencies:
-      '@types/node': 22.19.17
+      '@types/node': 22.19.19
 
   '@inquirer/confirm@3.2.0':
     dependencies:
@@ -7899,19 +7676,19 @@ snapshots:
     optionalDependencies:
       '@types/node': 18.19.130
 
-  '@inquirer/confirm@5.1.21(@types/node@20.19.39)':
+  '@inquirer/confirm@5.1.21(@types/node@20.19.41)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@20.19.39)
-      '@inquirer/type': 3.0.10(@types/node@20.19.39)
+      '@inquirer/core': 10.3.2(@types/node@20.19.41)
+      '@inquirer/type': 3.0.10(@types/node@20.19.41)
     optionalDependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
-  '@inquirer/confirm@5.1.21(@types/node@22.19.17)':
+  '@inquirer/confirm@5.1.21(@types/node@22.19.19)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@22.19.17)
-      '@inquirer/type': 3.0.10(@types/node@22.19.17)
+      '@inquirer/core': 10.3.2(@types/node@22.19.19)
+      '@inquirer/type': 3.0.10(@types/node@22.19.19)
     optionalDependencies:
-      '@types/node': 22.19.17
+      '@types/node': 22.19.19
 
   '@inquirer/core@10.3.2(@types/node@14.18.63)':
     dependencies:
@@ -7939,38 +7716,38 @@ snapshots:
     optionalDependencies:
       '@types/node': 18.19.130
 
-  '@inquirer/core@10.3.2(@types/node@20.19.39)':
+  '@inquirer/core@10.3.2(@types/node@20.19.41)':
     dependencies:
       '@inquirer/ansi': 1.0.2
       '@inquirer/figures': 1.0.15
-      '@inquirer/type': 3.0.10(@types/node@20.19.39)
+      '@inquirer/type': 3.0.10(@types/node@20.19.41)
       cli-width: 4.1.0
       mute-stream: 2.0.0
       signal-exit: 4.1.0
       wrap-ansi: 6.2.0
       yoctocolors-cjs: 2.1.3
     optionalDependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
-  '@inquirer/core@10.3.2(@types/node@22.19.17)':
+  '@inquirer/core@10.3.2(@types/node@22.19.19)':
     dependencies:
       '@inquirer/ansi': 1.0.2
       '@inquirer/figures': 1.0.15
-      '@inquirer/type': 3.0.10(@types/node@22.19.17)
+      '@inquirer/type': 3.0.10(@types/node@22.19.19)
       cli-width: 4.1.0
       mute-stream: 2.0.0
       signal-exit: 4.1.0
       wrap-ansi: 6.2.0
       yoctocolors-cjs: 2.1.3
     optionalDependencies:
-      '@types/node': 22.19.17
+      '@types/node': 22.19.19
 
   '@inquirer/core@9.2.1':
     dependencies:
       '@inquirer/figures': 1.0.15
       '@inquirer/type': 2.0.0
       '@types/mute-stream': 0.0.4
-      '@types/node': 22.19.17
+      '@types/node': 22.19.19
       '@types/wrap-ansi': 3.0.0
       ansi-escapes: 4.3.2
       cli-width: 4.1.0
@@ -7996,21 +7773,21 @@ snapshots:
     optionalDependencies:
       '@types/node': 18.19.130
 
-  '@inquirer/editor@4.2.23(@types/node@20.19.39)':
+  '@inquirer/editor@4.2.23(@types/node@20.19.41)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@20.19.39)
-      '@inquirer/external-editor': 1.0.3(@types/node@20.19.39)
-      '@inquirer/type': 3.0.10(@types/node@20.19.39)
+      '@inquirer/core': 10.3.2(@types/node@20.19.41)
+      '@inquirer/external-editor': 1.0.3(@types/node@20.19.41)
+      '@inquirer/type': 3.0.10(@types/node@20.19.41)
     optionalDependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
-  '@inquirer/editor@4.2.23(@types/node@22.19.17)':
+  '@inquirer/editor@4.2.23(@types/node@22.19.19)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@22.19.17)
-      '@inquirer/external-editor': 1.0.3(@types/node@22.19.17)
-      '@inquirer/type': 3.0.10(@types/node@22.19.17)
+      '@inquirer/core': 10.3.2(@types/node@22.19.19)
+      '@inquirer/external-editor': 1.0.3(@types/node@22.19.19)
+      '@inquirer/type': 3.0.10(@types/node@22.19.19)
     optionalDependencies:
-      '@types/node': 22.19.17
+      '@types/node': 22.19.19
 
   '@inquirer/expand@4.0.23(@types/node@14.18.63)':
     dependencies:
@@ -8028,21 +7805,21 @@ snapshots:
     optionalDependencies:
       '@types/node': 18.19.130
 
-  '@inquirer/expand@4.0.23(@types/node@20.19.39)':
+  '@inquirer/expand@4.0.23(@types/node@20.19.41)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@20.19.39)
-      '@inquirer/type': 3.0.10(@types/node@20.19.39)
+      '@inquirer/core': 10.3.2(@types/node@20.19.41)
+      '@inquirer/type': 3.0.10(@types/node@20.19.41)
       yoctocolors-cjs: 2.1.3
     optionalDependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
-  '@inquirer/expand@4.0.23(@types/node@22.19.17)':
+  '@inquirer/expand@4.0.23(@types/node@22.19.19)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@22.19.17)
-      '@inquirer/type': 3.0.10(@types/node@22.19.17)
+      '@inquirer/core': 10.3.2(@types/node@22.19.19)
+      '@inquirer/type': 3.0.10(@types/node@22.19.19)
       yoctocolors-cjs: 2.1.3
     optionalDependencies:
-      '@types/node': 22.19.17
+      '@types/node': 22.19.19
 
   '@inquirer/external-editor@1.0.3(@types/node@14.18.63)':
     dependencies:
@@ -8058,19 +7835,19 @@ snapshots:
     optionalDependencies:
       '@types/node': 18.19.130
 
-  '@inquirer/external-editor@1.0.3(@types/node@20.19.39)':
+  '@inquirer/external-editor@1.0.3(@types/node@20.19.41)':
     dependencies:
       chardet: 2.1.1
       iconv-lite: 0.7.2
     optionalDependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
-  '@inquirer/external-editor@1.0.3(@types/node@22.19.17)':
+  '@inquirer/external-editor@1.0.3(@types/node@22.19.19)':
     dependencies:
       chardet: 2.1.1
       iconv-lite: 0.7.2
     optionalDependencies:
-      '@types/node': 22.19.17
+      '@types/node': 22.19.19
 
   '@inquirer/figures@1.0.15': {}
 
@@ -8093,19 +7870,19 @@ snapshots:
     optionalDependencies:
       '@types/node': 18.19.130
 
-  '@inquirer/input@4.3.1(@types/node@20.19.39)':
+  '@inquirer/input@4.3.1(@types/node@20.19.41)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@20.19.39)
-      '@inquirer/type': 3.0.10(@types/node@20.19.39)
+      '@inquirer/core': 10.3.2(@types/node@20.19.41)
+      '@inquirer/type': 3.0.10(@types/node@20.19.41)
     optionalDependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
-  '@inquirer/input@4.3.1(@types/node@22.19.17)':
+  '@inquirer/input@4.3.1(@types/node@22.19.19)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@22.19.17)
-      '@inquirer/type': 3.0.10(@types/node@22.19.17)
+      '@inquirer/core': 10.3.2(@types/node@22.19.19)
+      '@inquirer/type': 3.0.10(@types/node@22.19.19)
     optionalDependencies:
-      '@types/node': 22.19.17
+      '@types/node': 22.19.19
 
   '@inquirer/number@3.0.23(@types/node@14.18.63)':
     dependencies:
@@ -8121,19 +7898,19 @@ snapshots:
     optionalDependencies:
       '@types/node': 18.19.130
 
-  '@inquirer/number@3.0.23(@types/node@20.19.39)':
+  '@inquirer/number@3.0.23(@types/node@20.19.41)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@20.19.39)
-      '@inquirer/type': 3.0.10(@types/node@20.19.39)
+      '@inquirer/core': 10.3.2(@types/node@20.19.41)
+      '@inquirer/type': 3.0.10(@types/node@20.19.41)
     optionalDependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
-  '@inquirer/number@3.0.23(@types/node@22.19.17)':
+  '@inquirer/number@3.0.23(@types/node@22.19.19)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@22.19.17)
-      '@inquirer/type': 3.0.10(@types/node@22.19.17)
+      '@inquirer/core': 10.3.2(@types/node@22.19.19)
+      '@inquirer/type': 3.0.10(@types/node@22.19.19)
     optionalDependencies:
-      '@types/node': 22.19.17
+      '@types/node': 22.19.19
 
   '@inquirer/password@4.0.23(@types/node@14.18.63)':
     dependencies:
@@ -8151,21 +7928,21 @@ snapshots:
     optionalDependencies:
       '@types/node': 18.19.130
 
-  '@inquirer/password@4.0.23(@types/node@20.19.39)':
+  '@inquirer/password@4.0.23(@types/node@20.19.41)':
     dependencies:
       '@inquirer/ansi': 1.0.2
-      '@inquirer/core': 10.3.2(@types/node@20.19.39)
-      '@inquirer/type': 3.0.10(@types/node@20.19.39)
+      '@inquirer/core': 10.3.2(@types/node@20.19.41)
+      '@inquirer/type': 3.0.10(@types/node@20.19.41)
     optionalDependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
-  '@inquirer/password@4.0.23(@types/node@22.19.17)':
+  '@inquirer/password@4.0.23(@types/node@22.19.19)':
     dependencies:
       '@inquirer/ansi': 1.0.2
-      '@inquirer/core': 10.3.2(@types/node@22.19.17)
-      '@inquirer/type': 3.0.10(@types/node@22.19.17)
+      '@inquirer/core': 10.3.2(@types/node@22.19.19)
+      '@inquirer/type': 3.0.10(@types/node@22.19.19)
     optionalDependencies:
-      '@types/node': 22.19.17
+      '@types/node': 22.19.19
 
   '@inquirer/prompts@7.10.1(@types/node@14.18.63)':
     dependencies:
@@ -8197,35 +7974,35 @@ snapshots:
     optionalDependencies:
       '@types/node': 18.19.130
 
-  '@inquirer/prompts@7.10.1(@types/node@20.19.39)':
-    dependencies:
-      '@inquirer/checkbox': 4.3.2(@types/node@20.19.39)
-      '@inquirer/confirm': 5.1.21(@types/node@20.19.39)
-      '@inquirer/editor': 4.2.23(@types/node@20.19.39)
-      '@inquirer/expand': 4.0.23(@types/node@20.19.39)
-      '@inquirer/input': 4.3.1(@types/node@20.19.39)
-      '@inquirer/number': 3.0.23(@types/node@20.19.39)
-      '@inquirer/password': 4.0.23(@types/node@20.19.39)
-      '@inquirer/rawlist': 4.1.11(@types/node@20.19.39)
-      '@inquirer/search': 3.2.2(@types/node@20.19.39)
-      '@inquirer/select': 4.4.2(@types/node@20.19.39)
+  '@inquirer/prompts@7.10.1(@types/node@20.19.41)':
+    dependencies:
+      '@inquirer/checkbox': 4.3.2(@types/node@20.19.41)
+      '@inquirer/confirm': 5.1.21(@types/node@20.19.41)
+      '@inquirer/editor': 4.2.23(@types/node@20.19.41)
+      '@inquirer/expand': 4.0.23(@types/node@20.19.41)
+      '@inquirer/input': 4.3.1(@types/node@20.19.41)
+      '@inquirer/number': 3.0.23(@types/node@20.19.41)
+      '@inquirer/password': 4.0.23(@types/node@20.19.41)
+      '@inquirer/rawlist': 4.1.11(@types/node@20.19.41)
+      '@inquirer/search': 3.2.2(@types/node@20.19.41)
+      '@inquirer/select': 4.4.2(@types/node@20.19.41)
     optionalDependencies:
-      '@types/node': 20.19.39
-
-  '@inquirer/prompts@7.10.1(@types/node@22.19.17)':
-    dependencies:
-      '@inquirer/checkbox': 4.3.2(@types/node@22.19.17)
-      '@inquirer/confirm': 5.1.21(@types/node@22.19.17)
-      '@inquirer/editor': 4.2.23(@types/node@22.19.17)
-      '@inquirer/expand': 4.0.23(@types/node@22.19.17)
-      '@inquirer/input': 4.3.1(@types/node@22.19.17)
-      '@inquirer/number': 3.0.23(@types/node@22.19.17)
-      '@inquirer/password': 4.0.23(@types/node@22.19.17)
-      '@inquirer/rawlist': 4.1.11(@types/node@22.19.17)
-      '@inquirer/search': 3.2.2(@types/node@22.19.17)
-      '@inquirer/select': 4.4.2(@types/node@22.19.17)
+      '@types/node': 20.19.41
+
+  '@inquirer/prompts@7.10.1(@types/node@22.19.19)':
+    dependencies:
+      '@inquirer/checkbox': 4.3.2(@types/node@22.19.19)
+      '@inquirer/confirm': 5.1.21(@types/node@22.19.19)
+      '@inquirer/editor': 4.2.23(@types/node@22.19.19)
+      '@inquirer/expand': 4.0.23(@types/node@22.19.19)
+      '@inquirer/input': 4.3.1(@types/node@22.19.19)
+      '@inquirer/number': 3.0.23(@types/node@22.19.19)
+      '@inquirer/password': 4.0.23(@types/node@22.19.19)
+      '@inquirer/rawlist': 4.1.11(@types/node@22.19.19)
+      '@inquirer/search': 3.2.2(@types/node@22.19.19)
+      '@inquirer/select': 4.4.2(@types/node@22.19.19)
     optionalDependencies:
-      '@types/node': 22.19.17
+      '@types/node': 22.19.19
 
   '@inquirer/rawlist@4.1.11(@types/node@14.18.63)':
     dependencies:
@@ -8243,21 +8020,21 @@ snapshots:
     optionalDependencies:
       '@types/node': 18.19.130
 
-  '@inquirer/rawlist@4.1.11(@types/node@20.19.39)':
+  '@inquirer/rawlist@4.1.11(@types/node@20.19.41)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@20.19.39)
-      '@inquirer/type': 3.0.10(@types/node@20.19.39)
+      '@inquirer/core': 10.3.2(@types/node@20.19.41)
+      '@inquirer/type': 3.0.10(@types/node@20.19.41)
       yoctocolors-cjs: 2.1.3
     optionalDependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
-  '@inquirer/rawlist@4.1.11(@types/node@22.19.17)':
+  '@inquirer/rawlist@4.1.11(@types/node@22.19.19)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@22.19.17)
-      '@inquirer/type': 3.0.10(@types/node@22.19.17)
+      '@inquirer/core': 10.3.2(@types/node@22.19.19)
+      '@inquirer/type': 3.0.10(@types/node@22.19.19)
       yoctocolors-cjs: 2.1.3
     optionalDependencies:
-      '@types/node': 22.19.17
+      '@types/node': 22.19.19
 
   '@inquirer/search@3.2.2(@types/node@14.18.63)':
     dependencies:
@@ -8277,23 +8054,23 @@ snapshots:
     optionalDependencies:
       '@types/node': 18.19.130
 
-  '@inquirer/search@3.2.2(@types/node@20.19.39)':
+  '@inquirer/search@3.2.2(@types/node@20.19.41)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@20.19.39)
+      '@inquirer/core': 10.3.2(@types/node@20.19.41)
       '@inquirer/figures': 1.0.15
-      '@inquirer/type': 3.0.10(@types/node@20.19.39)
+      '@inquirer/type': 3.0.10(@types/node@20.19.41)
       yoctocolors-cjs: 2.1.3
     optionalDependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
-  '@inquirer/search@3.2.2(@types/node@22.19.17)':
+  '@inquirer/search@3.2.2(@types/node@22.19.19)':
     dependencies:
-      '@inquirer/core': 10.3.2(@types/node@22.19.17)
+      '@inquirer/core': 10.3.2(@types/node@22.19.19)
       '@inquirer/figures': 1.0.15
-      '@inquirer/type': 3.0.10(@types/node@22.19.17)
+      '@inquirer/type': 3.0.10(@types/node@22.19.19)
       yoctocolors-cjs: 2.1.3
     optionalDependencies:
-      '@types/node': 22.19.17
+      '@types/node': 22.19.19
 
   '@inquirer/select@2.5.0':
     dependencies:
@@ -8323,25 +8100,25 @@ snapshots:
     optionalDependencies:
       '@types/node': 18.19.130
 
-  '@inquirer/select@4.4.2(@types/node@20.19.39)':
+  '@inquirer/select@4.4.2(@types/node@20.19.41)':
     dependencies:
       '@inquirer/ansi': 1.0.2
-      '@inquirer/core': 10.3.2(@types/node@20.19.39)
+      '@inquirer/core': 10.3.2(@types/node@20.19.41)
       '@inquirer/figures': 1.0.15
-      '@inquirer/type': 3.0.10(@types/node@20.19.39)
+      '@inquirer/type': 3.0.10(@types/node@20.19.41)
       yoctocolors-cjs: 2.1.3
     optionalDependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
-  '@inquirer/select@4.4.2(@types/node@22.19.17)':
+  '@inquirer/select@4.4.2(@types/node@22.19.19)':
     dependencies:
       '@inquirer/ansi': 1.0.2
-      '@inquirer/core': 10.3.2(@types/node@22.19.17)
+      '@inquirer/core': 10.3.2(@types/node@22.19.19)
       '@inquirer/figures': 1.0.15
-      '@inquirer/type': 3.0.10(@types/node@22.19.17)
+      '@inquirer/type': 3.0.10(@types/node@22.19.19)
       yoctocolors-cjs: 2.1.3
     optionalDependencies:
-      '@types/node': 22.19.17
+      '@types/node': 22.19.19
 
   '@inquirer/type@1.5.5':
     dependencies:
@@ -8359,13 +8136,13 @@ snapshots:
     optionalDependencies:
       '@types/node': 18.19.130
 
-  '@inquirer/type@3.0.10(@types/node@20.19.39)':
+  '@inquirer/type@3.0.10(@types/node@20.19.41)':
     optionalDependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
-  '@inquirer/type@3.0.10(@types/node@22.19.17)':
+  '@inquirer/type@3.0.10(@types/node@22.19.19)':
     optionalDependencies:
-      '@types/node': 22.19.17
+      '@types/node': 22.19.19
 
   '@isaacs/fs-minipass@4.0.1':
     dependencies:
@@ -8384,7 +8161,7 @@ snapshots:
   '@jest/console@29.7.0':
     dependencies:
       '@jest/types': 29.6.3
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
       chalk: 4.1.2
       jest-message-util: 29.7.0
       jest-util: 29.7.0
@@ -8397,14 +8174,14 @@ snapshots:
       '@jest/test-result': 29.7.0
       '@jest/transform': 29.7.0
       '@jest/types': 29.6.3
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
       ansi-escapes: 4.3.2
       chalk: 4.1.2
       ci-info: 3.9.0
       exit: 0.1.2
       graceful-fs: 4.2.11
       jest-changed-files: 29.7.0
-      jest-config: 29.7.0(@types/node@20.19.39)(ts-node@8.10.2(typescript@5.9.3))
+      jest-config: 29.7.0(@types/node@20.19.41)(ts-node@8.10.2(typescript@5.9.3))
       jest-haste-map: 29.7.0
       jest-message-util: 29.7.0
       jest-regex-util: 29.6.3
@@ -8429,7 +8206,7 @@ snapshots:
     dependencies:
       '@jest/fake-timers': 29.7.0
       '@jest/types': 29.6.3
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
       jest-mock: 29.7.0
 
   '@jest/expect-utils@29.7.0':
@@ -8447,7 +8224,7 @@ snapshots:
     dependencies:
       '@jest/types': 29.6.3
       '@sinonjs/fake-timers': 10.3.0
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
       jest-message-util: 29.7.0
       jest-mock: 29.7.0
       jest-util: 29.7.0
@@ -8469,7 +8246,7 @@ snapshots:
       '@jest/transform': 29.7.0
       '@jest/types': 29.6.3
       '@jridgewell/trace-mapping': 0.3.31
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
       chalk: 4.1.2
       collect-v8-coverage: 1.0.3
       exit: 0.1.2
@@ -8538,7 +8315,7 @@ snapshots:
     dependencies:
       '@types/istanbul-lib-coverage': 2.0.6
       '@types/istanbul-reports': 3.0.4
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
       '@types/yargs': 15.0.20
       chalk: 4.1.2
 
@@ -8547,7 +8324,7 @@ snapshots:
       '@jest/schemas': 29.6.3
       '@types/istanbul-lib-coverage': 2.0.6
       '@types/istanbul-reports': 3.0.4
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
       '@types/yargs': 17.0.35
       chalk: 4.1.2
 
@@ -8583,9 +8360,11 @@ snapshots:
     dependencies:
       '@emnapi/core': 1.10.0
       '@emnapi/runtime': 1.10.0
-      '@tybys/wasm-util': 0.10.1
+      '@tybys/wasm-util': 0.10.2
     optional: true
 
+  '@nodable/entities@2.1.0': {}
+
   '@nodelib/fs.scandir@2.1.5':
     dependencies:
       '@nodelib/fs.stat': 2.0.5
@@ -8600,7 +8379,7 @@ snapshots:
 
   '@nolyfill/is-core-module@1.0.39': {}
 
-  '@oclif/core@4.10.5':
+  '@oclif/core@4.11.2':
     dependencies:
       ansi-escapes: 4.3.2
       ansis: 3.17.0
@@ -8613,7 +8392,7 @@ snapshots:
       is-wsl: 2.2.0
       lilconfig: 3.1.3
       minimatch: 10.2.5
-      semver: 7.7.4
+      semver: 7.8.0
       string-width: 4.2.3
       supports-color: 8.1.1
       tinyglobby: 0.2.16
@@ -8634,7 +8413,7 @@ snapshots:
       is-wsl: 2.2.0
       lilconfig: 3.1.3
       minimatch: 10.2.5
-      semver: 7.7.4
+      semver: 7.8.0
       string-width: 4.2.3
       supports-color: 8.1.1
       tinyglobby: 0.2.16
@@ -8642,49 +8421,49 @@ snapshots:
       wordwrap: 1.0.0
       wrap-ansi: 7.0.0
 
-  '@oclif/plugin-help@6.2.44':
+  '@oclif/plugin-help@6.2.48':
     dependencies:
-      '@oclif/core': 4.10.5
+      '@oclif/core': 4.11.2
 
-  '@oclif/plugin-not-found@3.2.80(@types/node@14.18.63)':
+  '@oclif/plugin-not-found@3.2.85(@types/node@14.18.63)':
     dependencies:
       '@inquirer/prompts': 7.10.1(@types/node@14.18.63)
-      '@oclif/core': 4.10.5
+      '@oclif/core': 4.11.2
       ansis: 3.17.0
       fast-levenshtein: 3.0.0
     transitivePeerDependencies:
       - '@types/node'
 
-  '@oclif/plugin-not-found@3.2.80(@types/node@18.19.130)':
+  '@oclif/plugin-not-found@3.2.85(@types/node@18.19.130)':
     dependencies:
       '@inquirer/prompts': 7.10.1(@types/node@18.19.130)
-      '@oclif/core': 4.10.5
+      '@oclif/core': 4.11.2
       ansis: 3.17.0
       fast-levenshtein: 3.0.0
     transitivePeerDependencies:
       - '@types/node'
 
-  '@oclif/plugin-not-found@3.2.80(@types/node@20.19.39)':
+  '@oclif/plugin-not-found@3.2.85(@types/node@20.19.41)':
     dependencies:
-      '@inquirer/prompts': 7.10.1(@types/node@20.19.39)
-      '@oclif/core': 4.10.5
+      '@inquirer/prompts': 7.10.1(@types/node@20.19.41)
+      '@oclif/core': 4.11.2
       ansis: 3.17.0
       fast-levenshtein: 3.0.0
     transitivePeerDependencies:
       - '@types/node'
 
-  '@oclif/plugin-not-found@3.2.80(@types/node@22.19.17)':
+  '@oclif/plugin-not-found@3.2.85(@types/node@22.19.19)':
     dependencies:
-      '@inquirer/prompts': 7.10.1(@types/node@22.19.17)
-      '@oclif/core': 4.10.5
+      '@inquirer/prompts': 7.10.1(@types/node@22.19.19)
+      '@oclif/core': 4.11.2
       ansis: 3.17.0
       fast-levenshtein: 3.0.0
     transitivePeerDependencies:
       - '@types/node'
 
-  '@oclif/plugin-warn-if-update-available@3.1.60':
+  '@oclif/plugin-warn-if-update-available@3.1.64':
     dependencies:
-      '@oclif/core': 4.9.0
+      '@oclif/core': 4.11.2
       ansis: 3.17.0
       debug: 4.4.3(supports-color@8.1.1)
       http-call: 5.3.0
@@ -8693,9 +8472,9 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@oclif/test@4.1.18(@oclif/core@4.10.5)':
+  '@oclif/test@4.1.18(@oclif/core@4.11.2)':
     dependencies:
-      '@oclif/core': 4.10.5
+      '@oclif/core': 4.11.2
       ansis: 3.17.0
       debug: 4.4.3(supports-color@8.1.1)
     transitivePeerDependencies:
@@ -8764,7 +8543,7 @@ snapshots:
     dependencies:
       '@sinonjs/commons': 3.0.1
 
-  '@sinonjs/fake-timers@15.3.2':
+  '@sinonjs/fake-timers@15.4.0':
     dependencies:
       '@sinonjs/commons': 3.0.1
 
@@ -8780,251 +8559,163 @@ snapshots:
 
   '@sinonjs/text-encoding@0.7.3': {}
 
-  '@smithy/chunked-blob-reader-native@4.2.3':
-    dependencies:
-      '@smithy/util-base64': 4.3.2
-      tslib: 2.8.1
-
-  '@smithy/chunked-blob-reader@5.2.2':
-    dependencies:
-      tslib: 2.8.1
-
-  '@smithy/config-resolver@4.4.17':
-    dependencies:
-      '@smithy/node-config-provider': 4.3.14
-      '@smithy/types': 4.14.1
-      '@smithy/util-config-provider': 4.2.2
-      '@smithy/util-endpoints': 3.4.2
-      '@smithy/util-middleware': 4.2.14
-      tslib: 2.8.1
-
-  '@smithy/core@3.23.16':
-    dependencies:
-      '@smithy/protocol-http': 5.3.14
-      '@smithy/types': 4.14.1
-      '@smithy/url-parser': 4.2.14
-      '@smithy/util-base64': 4.3.2
-      '@smithy/util-body-length-browser': 4.2.2
-      '@smithy/util-middleware': 4.2.14
-      '@smithy/util-stream': 4.5.24
-      '@smithy/util-utf8': 4.2.2
-      '@smithy/uuid': 1.1.2
-      tslib: 2.8.1
-
-  '@smithy/credential-provider-imds@4.2.14':
+  '@smithy/config-resolver@4.5.1':
     dependencies:
-      '@smithy/node-config-provider': 4.3.14
-      '@smithy/property-provider': 4.2.14
-      '@smithy/types': 4.14.1
-      '@smithy/url-parser': 4.2.14
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/eventstream-codec@4.2.14':
+  '@smithy/core@3.24.1':
     dependencies:
       '@aws-crypto/crc32': 5.2.0
       '@smithy/types': 4.14.1
-      '@smithy/util-hex-encoding': 4.2.2
       tslib: 2.8.1
 
-  '@smithy/eventstream-serde-browser@4.2.14':
+  '@smithy/credential-provider-imds@4.3.1':
     dependencies:
-      '@smithy/eventstream-serde-universal': 4.2.14
+      '@smithy/core': 3.24.1
       '@smithy/types': 4.14.1
       tslib: 2.8.1
 
-  '@smithy/eventstream-serde-config-resolver@4.3.14':
+  '@smithy/eventstream-serde-browser@4.3.1':
     dependencies:
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/eventstream-serde-node@4.2.14':
+  '@smithy/eventstream-serde-config-resolver@4.4.1':
     dependencies:
-      '@smithy/eventstream-serde-universal': 4.2.14
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/eventstream-serde-universal@4.2.14':
+  '@smithy/eventstream-serde-node@4.3.1':
     dependencies:
-      '@smithy/eventstream-codec': 4.2.14
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/fetch-http-handler@5.3.17':
+  '@smithy/fetch-http-handler@5.4.1':
     dependencies:
-      '@smithy/protocol-http': 5.3.14
-      '@smithy/querystring-builder': 4.2.14
+      '@smithy/core': 3.24.1
       '@smithy/types': 4.14.1
-      '@smithy/util-base64': 4.3.2
       tslib: 2.8.1
 
-  '@smithy/hash-blob-browser@4.2.15':
+  '@smithy/hash-blob-browser@4.3.1':
     dependencies:
-      '@smithy/chunked-blob-reader': 5.2.2
-      '@smithy/chunked-blob-reader-native': 4.2.3
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/hash-node@4.2.14':
+  '@smithy/hash-node@4.3.1':
     dependencies:
-      '@smithy/types': 4.14.1
-      '@smithy/util-buffer-from': 4.2.2
-      '@smithy/util-utf8': 4.2.2
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/hash-stream-node@4.2.14':
+  '@smithy/hash-stream-node@4.3.1':
     dependencies:
-      '@smithy/types': 4.14.1
-      '@smithy/util-utf8': 4.2.2
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/invalid-dependency@4.2.14':
+  '@smithy/invalid-dependency@4.3.1':
     dependencies:
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
   '@smithy/is-array-buffer@2.2.0':
     dependencies:
       tslib: 2.8.1
 
-  '@smithy/is-array-buffer@4.2.2':
-    dependencies:
-      tslib: 2.8.1
-
-  '@smithy/md5-js@4.2.14':
-    dependencies:
-      '@smithy/types': 4.14.1
-      '@smithy/util-utf8': 4.2.2
-      tslib: 2.8.1
-
-  '@smithy/middleware-content-length@4.2.14':
+  '@smithy/is-array-buffer@4.3.1':
     dependencies:
-      '@smithy/protocol-http': 5.3.14
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/middleware-endpoint@4.4.31':
+  '@smithy/md5-js@4.3.1':
     dependencies:
-      '@smithy/core': 3.23.16
-      '@smithy/middleware-serde': 4.2.19
-      '@smithy/node-config-provider': 4.3.14
-      '@smithy/shared-ini-file-loader': 4.4.9
-      '@smithy/types': 4.14.1
-      '@smithy/url-parser': 4.2.14
-      '@smithy/util-middleware': 4.2.14
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/middleware-retry@4.5.4':
+  '@smithy/middleware-content-length@4.3.1':
     dependencies:
-      '@smithy/core': 3.23.16
-      '@smithy/node-config-provider': 4.3.14
-      '@smithy/protocol-http': 5.3.14
-      '@smithy/service-error-classification': 4.3.0
-      '@smithy/smithy-client': 4.12.12
-      '@smithy/types': 4.14.1
-      '@smithy/util-middleware': 4.2.14
-      '@smithy/util-retry': 4.3.3
-      '@smithy/uuid': 1.1.2
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/middleware-serde@4.2.19':
+  '@smithy/middleware-endpoint@4.5.1':
     dependencies:
-      '@smithy/core': 3.23.16
-      '@smithy/protocol-http': 5.3.14
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/middleware-stack@4.2.14':
+  '@smithy/middleware-retry@4.6.1':
     dependencies:
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/node-config-provider@4.3.14':
+  '@smithy/middleware-serde@4.3.1':
     dependencies:
-      '@smithy/property-provider': 4.2.14
-      '@smithy/shared-ini-file-loader': 4.4.9
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/node-http-handler@4.6.0':
+  '@smithy/middleware-stack@4.3.1':
     dependencies:
-      '@smithy/protocol-http': 5.3.14
-      '@smithy/querystring-builder': 4.2.14
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/property-provider@4.2.14':
+  '@smithy/node-config-provider@4.4.1':
     dependencies:
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/protocol-http@5.3.14':
+  '@smithy/node-http-handler@4.7.1':
     dependencies:
+      '@smithy/core': 3.24.1
       '@smithy/types': 4.14.1
       tslib: 2.8.1
 
-  '@smithy/querystring-builder@4.2.14':
+  '@smithy/property-provider@4.3.1':
     dependencies:
-      '@smithy/types': 4.14.1
-      '@smithy/util-uri-escape': 4.2.2
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/querystring-parser@4.2.14':
+  '@smithy/protocol-http@5.4.1':
     dependencies:
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/service-error-classification@4.3.0':
-    dependencies:
-      '@smithy/types': 4.14.1
-
-  '@smithy/shared-ini-file-loader@4.4.9':
+  '@smithy/shared-ini-file-loader@4.5.1':
     dependencies:
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/signature-v4@5.3.14':
+  '@smithy/signature-v4@5.4.1':
     dependencies:
-      '@smithy/is-array-buffer': 4.2.2
-      '@smithy/protocol-http': 5.3.14
+      '@smithy/core': 3.24.1
       '@smithy/types': 4.14.1
-      '@smithy/util-hex-encoding': 4.2.2
-      '@smithy/util-middleware': 4.2.14
-      '@smithy/util-uri-escape': 4.2.2
-      '@smithy/util-utf8': 4.2.2
       tslib: 2.8.1
 
-  '@smithy/smithy-client@4.12.12':
+  '@smithy/smithy-client@4.13.1':
     dependencies:
-      '@smithy/core': 3.23.16
-      '@smithy/middleware-endpoint': 4.4.31
-      '@smithy/middleware-stack': 4.2.14
-      '@smithy/protocol-http': 5.3.14
+      '@smithy/core': 3.24.1
       '@smithy/types': 4.14.1
-      '@smithy/util-stream': 4.5.24
       tslib: 2.8.1
 
   '@smithy/types@4.14.1':
     dependencies:
       tslib: 2.8.1
 
-  '@smithy/url-parser@4.2.14':
+  '@smithy/url-parser@4.3.1':
     dependencies:
-      '@smithy/querystring-parser': 4.2.14
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/util-base64@4.3.2':
+  '@smithy/util-base64@4.4.1':
     dependencies:
-      '@smithy/util-buffer-from': 4.2.2
-      '@smithy/util-utf8': 4.2.2
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/util-body-length-browser@4.2.2':
+  '@smithy/util-body-length-browser@4.3.1':
     dependencies:
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/util-body-length-node@4.2.3':
+  '@smithy/util-body-length-node@4.3.1':
     dependencies:
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
   '@smithy/util-buffer-from@2.2.0':
@@ -9032,66 +8723,39 @@ snapshots:
       '@smithy/is-array-buffer': 2.2.0
       tslib: 2.8.1
 
-  '@smithy/util-buffer-from@4.2.2':
-    dependencies:
-      '@smithy/is-array-buffer': 4.2.2
-      tslib: 2.8.1
-
-  '@smithy/util-config-provider@4.2.2':
-    dependencies:
-      tslib: 2.8.1
-
-  '@smithy/util-defaults-mode-browser@4.3.48':
-    dependencies:
-      '@smithy/property-provider': 4.2.14
-      '@smithy/smithy-client': 4.12.12
-      '@smithy/types': 4.14.1
-      tslib: 2.8.1
-
-  '@smithy/util-defaults-mode-node@4.2.53':
+  '@smithy/util-config-provider@4.3.1':
     dependencies:
-      '@smithy/config-resolver': 4.4.17
-      '@smithy/credential-provider-imds': 4.2.14
-      '@smithy/node-config-provider': 4.3.14
-      '@smithy/property-provider': 4.2.14
-      '@smithy/smithy-client': 4.12.12
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/util-endpoints@3.4.2':
+  '@smithy/util-defaults-mode-browser@4.4.1':
     dependencies:
-      '@smithy/node-config-provider': 4.3.14
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/util-hex-encoding@4.2.2':
+  '@smithy/util-defaults-mode-node@4.3.1':
     dependencies:
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/util-middleware@4.2.14':
+  '@smithy/util-endpoints@3.5.1':
     dependencies:
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/util-retry@4.3.3':
+  '@smithy/util-middleware@4.3.1':
     dependencies:
-      '@smithy/service-error-classification': 4.3.0
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/util-stream@4.5.24':
+  '@smithy/util-retry@4.4.1':
     dependencies:
-      '@smithy/fetch-http-handler': 5.3.17
-      '@smithy/node-http-handler': 4.6.0
-      '@smithy/types': 4.14.1
-      '@smithy/util-base64': 4.3.2
-      '@smithy/util-buffer-from': 4.2.2
-      '@smithy/util-hex-encoding': 4.2.2
-      '@smithy/util-utf8': 4.2.2
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/util-uri-escape@4.2.2':
+  '@smithy/util-stream@4.6.1':
     dependencies:
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
   '@smithy/util-utf8@2.3.0':
@@ -9099,18 +8763,14 @@ snapshots:
       '@smithy/util-buffer-from': 2.2.0
       tslib: 2.8.1
 
-  '@smithy/util-utf8@4.2.2':
-    dependencies:
-      '@smithy/util-buffer-from': 4.2.2
-      tslib: 2.8.1
-
-  '@smithy/util-waiter@4.2.16':
+  '@smithy/util-utf8@4.3.1':
     dependencies:
-      '@smithy/types': 4.14.1
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
-  '@smithy/uuid@1.1.2':
+  '@smithy/util-waiter@4.4.1':
     dependencies:
+      '@smithy/core': 3.24.1
       tslib: 2.8.1
 
   '@so-ric/colorspace@1.1.6':
@@ -9120,7 +8780,7 @@ snapshots:
 
   '@stylistic/eslint-plugin@3.1.0(eslint@8.57.1)(typescript@4.9.5)':
     dependencies:
-      '@typescript-eslint/utils': 8.59.0(eslint@8.57.1)(typescript@4.9.5)
+      '@typescript-eslint/utils': 8.59.3(eslint@8.57.1)(typescript@4.9.5)
       eslint: 8.57.1
       eslint-visitor-keys: 4.2.1
       espree: 10.4.0
@@ -9132,7 +8792,7 @@ snapshots:
 
   '@stylistic/eslint-plugin@3.1.0(eslint@8.57.1)(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/utils': 8.59.0(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.59.3(eslint@8.57.1)(typescript@5.9.3)
       eslint: 8.57.1
       eslint-visitor-keys: 4.2.1
       espree: 10.4.0
@@ -9142,16 +8802,50 @@ snapshots:
       - supports-color
       - typescript
 
+  '@stylistic/eslint-plugin@3.1.0(eslint@9.39.4)(typescript@4.9.5)':
+    dependencies:
+      '@typescript-eslint/utils': 8.59.3(eslint@9.39.4)(typescript@4.9.5)
+      eslint: 9.39.4
+      eslint-visitor-keys: 4.2.1
+      espree: 10.4.0
+      estraverse: 5.3.0
+      picomatch: 4.0.4
+    transitivePeerDependencies:
+      - supports-color
+      - typescript
+
+  '@stylistic/eslint-plugin@3.1.0(eslint@9.39.4)(typescript@5.9.3)':
+    dependencies:
+      '@typescript-eslint/utils': 8.59.3(eslint@9.39.4)(typescript@5.9.3)
+      eslint: 9.39.4
+      eslint-visitor-keys: 4.2.1
+      espree: 10.4.0
+      estraverse: 5.3.0
+      picomatch: 4.0.4
+    transitivePeerDependencies:
+      - supports-color
+      - typescript
+
   '@stylistic/eslint-plugin@5.10.0(eslint@8.57.1)':
     dependencies:
       '@eslint-community/eslint-utils': 4.9.1(eslint@8.57.1)
-      '@typescript-eslint/types': 8.59.0
+      '@typescript-eslint/types': 8.59.3
       eslint: 8.57.1
       eslint-visitor-keys: 4.2.1
       espree: 10.4.0
       estraverse: 5.3.0
       picomatch: 4.0.4
 
+  '@stylistic/eslint-plugin@5.10.0(eslint@9.39.4)':
+    dependencies:
+      '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.4)
+      '@typescript-eslint/types': 8.59.3
+      eslint: 9.39.4
+      eslint-visitor-keys: 4.2.1
+      espree: 10.4.0
+      estraverse: 5.3.0
+      picomatch: 4.0.4
+
   '@szmarczak/http-timer@5.0.1':
     dependencies:
       defer-to-connect: 2.0.1
@@ -9164,14 +8858,14 @@ snapshots:
 
   '@tsconfig/node16@1.0.4': {}
 
-  '@tybys/wasm-util@0.10.1':
+  '@tybys/wasm-util@0.10.2':
     dependencies:
       tslib: 2.8.1
     optional: true
 
   '@types/babel__core@7.20.5':
     dependencies:
-      '@babel/parser': 7.29.2
+      '@babel/parser': 7.29.3
       '@babel/types': 7.29.0
       '@types/babel__generator': 7.27.0
       '@types/babel__template': 7.4.4
@@ -9183,7 +8877,7 @@ snapshots:
 
   '@types/babel__template@7.4.4':
     dependencies:
-      '@babel/parser': 7.29.2
+      '@babel/parser': 7.29.3
       '@babel/types': 7.29.0
 
   '@types/babel__traverse@7.28.0':
@@ -9192,24 +8886,22 @@ snapshots:
 
   '@types/big-json@3.2.5':
     dependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
   '@types/bluebird@3.5.42': {}
 
   '@types/chai@4.3.20': {}
 
-  '@types/estree@1.0.8': {}
-
-  '@types/flat@5.0.5': {}
+  '@types/estree@1.0.9': {}
 
   '@types/fs-extra@11.0.4':
     dependencies:
       '@types/jsonfile': 6.1.4
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
   '@types/graceful-fs@4.1.9':
     dependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
   '@types/http-cache-semantics@4.2.0': {}
 
@@ -9239,7 +8931,7 @@ snapshots:
 
   '@types/jsonfile@6.1.4':
     dependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
   '@types/linkify-it@5.0.0': {}
 
@@ -9254,7 +8946,7 @@ snapshots:
 
   '@types/mkdirp@1.0.2':
     dependencies:
-      '@types/node': 18.19.130
+      '@types/node': 20.19.41
 
   '@types/mocha@10.0.10': {}
 
@@ -9262,7 +8954,7 @@ snapshots:
 
   '@types/mute-stream@0.0.4':
     dependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
   '@types/node@14.18.63': {}
 
@@ -9270,11 +8962,11 @@ snapshots:
     dependencies:
       undici-types: 5.26.5
 
-  '@types/node@20.19.39':
+  '@types/node@20.19.41':
     dependencies:
       undici-types: 6.21.0
 
-  '@types/node@22.19.17':
+  '@types/node@22.19.19':
     dependencies:
       undici-types: 6.21.0
 
@@ -9282,7 +8974,7 @@ snapshots:
 
   '@types/progress-stream@2.0.5':
     dependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
   '@types/rewire@2.5.30': {}
 
@@ -9302,12 +8994,12 @@ snapshots:
 
   '@types/tar@6.1.13':
     dependencies:
-      '@types/node': 18.19.130
+      '@types/node': 20.19.41
       minipass: 4.2.8
 
   '@types/through@0.0.33':
     dependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
   '@types/tmp@0.2.6': {}
 
@@ -9327,72 +9019,72 @@ snapshots:
     dependencies:
       '@types/yargs-parser': 21.0.3
 
-  '@typescript-eslint/eslint-plugin@5.62.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@4.9.5))(eslint@8.57.1)(typescript@4.9.5)':
+  '@typescript-eslint/eslint-plugin@5.62.0(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@4.9.5))(eslint@9.39.4)(typescript@4.9.5)':
     dependencies:
       '@eslint-community/regexpp': 4.12.2
-      '@typescript-eslint/parser': 8.59.0(eslint@8.57.1)(typescript@4.9.5)
+      '@typescript-eslint/parser': 8.59.3(eslint@9.39.4)(typescript@4.9.5)
       '@typescript-eslint/scope-manager': 5.62.0
-      '@typescript-eslint/type-utils': 5.62.0(eslint@8.57.1)(typescript@4.9.5)
-      '@typescript-eslint/utils': 5.62.0(eslint@8.57.1)(typescript@4.9.5)
+      '@typescript-eslint/type-utils': 5.62.0(eslint@9.39.4)(typescript@4.9.5)
+      '@typescript-eslint/utils': 5.62.0(eslint@9.39.4)(typescript@4.9.5)
       debug: 4.4.3(supports-color@8.1.1)
-      eslint: 8.57.1
+      eslint: 9.39.4
       graphemer: 1.4.0
       ignore: 5.3.2
       natural-compare-lite: 1.4.0
-      semver: 7.7.4
+      semver: 7.8.0
       tsutils: 3.21.0(typescript@4.9.5)
     optionalDependencies:
       typescript: 4.9.5
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/eslint-plugin@5.62.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1)(typescript@5.9.3)':
+  '@typescript-eslint/eslint-plugin@5.62.0(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@5.9.3))(eslint@9.39.4)(typescript@5.9.3)':
     dependencies:
       '@eslint-community/regexpp': 4.12.2
-      '@typescript-eslint/parser': 8.59.0(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/parser': 8.59.3(eslint@9.39.4)(typescript@5.9.3)
       '@typescript-eslint/scope-manager': 5.62.0
-      '@typescript-eslint/type-utils': 5.62.0(eslint@8.57.1)(typescript@5.9.3)
-      '@typescript-eslint/utils': 5.62.0(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/type-utils': 5.62.0(eslint@9.39.4)(typescript@5.9.3)
+      '@typescript-eslint/utils': 5.62.0(eslint@9.39.4)(typescript@5.9.3)
       debug: 4.4.3(supports-color@8.1.1)
-      eslint: 8.57.1
+      eslint: 9.39.4
       graphemer: 1.4.0
       ignore: 5.3.2
       natural-compare-lite: 1.4.0
-      semver: 7.7.4
+      semver: 7.8.0
       tsutils: 3.21.0(typescript@5.9.3)
     optionalDependencies:
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/eslint-plugin@6.21.0(@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1)(typescript@5.9.3)':
+  '@typescript-eslint/eslint-plugin@6.21.0(@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3))(eslint@9.39.4)(typescript@5.9.3)':
     dependencies:
       '@eslint-community/regexpp': 4.12.2
-      '@typescript-eslint/parser': 6.21.0(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/parser': 6.21.0(eslint@9.39.4)(typescript@5.9.3)
       '@typescript-eslint/scope-manager': 6.21.0
-      '@typescript-eslint/type-utils': 6.21.0(eslint@8.57.1)(typescript@5.9.3)
-      '@typescript-eslint/utils': 6.21.0(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/type-utils': 6.21.0(eslint@9.39.4)(typescript@5.9.3)
+      '@typescript-eslint/utils': 6.21.0(eslint@9.39.4)(typescript@5.9.3)
       '@typescript-eslint/visitor-keys': 6.21.0
       debug: 4.4.3(supports-color@8.1.1)
-      eslint: 8.57.1
+      eslint: 9.39.4
       graphemer: 1.4.0
       ignore: 5.3.2
       natural-compare: 1.4.0
-      semver: 7.7.4
+      semver: 7.8.0
       ts-api-utils: 1.4.3(typescript@5.9.3)
     optionalDependencies:
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/eslint-plugin@8.59.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@4.9.5))(eslint@8.57.1)(typescript@4.9.5)':
+  '@typescript-eslint/eslint-plugin@8.59.3(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@4.9.5))(eslint@8.57.1)(typescript@4.9.5)':
     dependencies:
       '@eslint-community/regexpp': 4.12.2
-      '@typescript-eslint/parser': 8.59.0(eslint@8.57.1)(typescript@4.9.5)
-      '@typescript-eslint/scope-manager': 8.59.0
-      '@typescript-eslint/type-utils': 8.59.0(eslint@8.57.1)(typescript@4.9.5)
-      '@typescript-eslint/utils': 8.59.0(eslint@8.57.1)(typescript@4.9.5)
-      '@typescript-eslint/visitor-keys': 8.59.0
+      '@typescript-eslint/parser': 8.59.3(eslint@8.57.1)(typescript@4.9.5)
+      '@typescript-eslint/scope-manager': 8.59.3
+      '@typescript-eslint/type-utils': 8.59.3(eslint@8.57.1)(typescript@4.9.5)
+      '@typescript-eslint/utils': 8.59.3(eslint@8.57.1)(typescript@4.9.5)
+      '@typescript-eslint/visitor-keys': 8.59.3
       eslint: 8.57.1
       ignore: 7.0.5
       natural-compare: 1.4.0
@@ -9401,14 +9093,14 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/eslint-plugin@8.59.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1)(typescript@5.9.3)':
+  '@typescript-eslint/eslint-plugin@8.59.3(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1)(typescript@5.9.3)':
     dependencies:
       '@eslint-community/regexpp': 4.12.2
-      '@typescript-eslint/parser': 8.59.0(eslint@8.57.1)(typescript@5.9.3)
-      '@typescript-eslint/scope-manager': 8.59.0
-      '@typescript-eslint/type-utils': 8.59.0(eslint@8.57.1)(typescript@5.9.3)
-      '@typescript-eslint/utils': 8.59.0(eslint@8.57.1)(typescript@5.9.3)
-      '@typescript-eslint/visitor-keys': 8.59.0
+      '@typescript-eslint/parser': 8.59.3(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/scope-manager': 8.59.3
+      '@typescript-eslint/type-utils': 8.59.3(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.59.3(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/visitor-keys': 8.59.3
       eslint: 8.57.1
       ignore: 7.0.5
       natural-compare: 1.4.0
@@ -9417,56 +9109,112 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.9.3)':
+  '@typescript-eslint/eslint-plugin@8.59.3(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@4.9.5))(eslint@9.39.4)(typescript@4.9.5)':
+    dependencies:
+      '@eslint-community/regexpp': 4.12.2
+      '@typescript-eslint/parser': 8.59.3(eslint@9.39.4)(typescript@4.9.5)
+      '@typescript-eslint/scope-manager': 8.59.3
+      '@typescript-eslint/type-utils': 8.59.3(eslint@9.39.4)(typescript@4.9.5)
+      '@typescript-eslint/utils': 8.59.3(eslint@9.39.4)(typescript@4.9.5)
+      '@typescript-eslint/visitor-keys': 8.59.3
+      eslint: 9.39.4
+      ignore: 7.0.5
+      natural-compare: 1.4.0
+      ts-api-utils: 2.5.0(typescript@4.9.5)
+      typescript: 4.9.5
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/eslint-plugin@8.59.3(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@5.9.3))(eslint@9.39.4)(typescript@5.9.3)':
+    dependencies:
+      '@eslint-community/regexpp': 4.12.2
+      '@typescript-eslint/parser': 8.59.3(eslint@9.39.4)(typescript@5.9.3)
+      '@typescript-eslint/scope-manager': 8.59.3
+      '@typescript-eslint/type-utils': 8.59.3(eslint@9.39.4)(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.59.3(eslint@9.39.4)(typescript@5.9.3)
+      '@typescript-eslint/visitor-keys': 8.59.3
+      eslint: 9.39.4
+      ignore: 7.0.5
+      natural-compare: 1.4.0
+      ts-api-utils: 2.5.0(typescript@5.9.3)
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3)':
     dependencies:
       '@typescript-eslint/scope-manager': 6.21.0
       '@typescript-eslint/types': 6.21.0
       '@typescript-eslint/typescript-estree': 6.21.0(typescript@5.9.3)
       '@typescript-eslint/visitor-keys': 6.21.0
       debug: 4.4.3(supports-color@8.1.1)
-      eslint: 8.57.1
+      eslint: 9.39.4
     optionalDependencies:
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@4.9.5)':
+  '@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@4.9.5)':
     dependencies:
-      '@typescript-eslint/scope-manager': 8.59.0
-      '@typescript-eslint/types': 8.59.0
-      '@typescript-eslint/typescript-estree': 8.59.0(typescript@4.9.5)
-      '@typescript-eslint/visitor-keys': 8.59.0
+      '@typescript-eslint/scope-manager': 8.59.3
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/typescript-estree': 8.59.3(typescript@4.9.5)
+      '@typescript-eslint/visitor-keys': 8.59.3
       debug: 4.4.3(supports-color@8.1.1)
       eslint: 8.57.1
       typescript: 4.9.5
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3)':
+  '@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/scope-manager': 8.59.0
-      '@typescript-eslint/types': 8.59.0
-      '@typescript-eslint/typescript-estree': 8.59.0(typescript@5.9.3)
-      '@typescript-eslint/visitor-keys': 8.59.0
+      '@typescript-eslint/scope-manager': 8.59.3
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/typescript-estree': 8.59.3(typescript@5.9.3)
+      '@typescript-eslint/visitor-keys': 8.59.3
       debug: 4.4.3(supports-color@8.1.1)
       eslint: 8.57.1
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/project-service@8.59.0(typescript@4.9.5)':
+  '@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@4.9.5)':
+    dependencies:
+      '@typescript-eslint/scope-manager': 8.59.3
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/typescript-estree': 8.59.3(typescript@4.9.5)
+      '@typescript-eslint/visitor-keys': 8.59.3
+      debug: 4.4.3(supports-color@8.1.1)
+      eslint: 9.39.4
+      typescript: 4.9.5
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@5.9.3)':
+    dependencies:
+      '@typescript-eslint/scope-manager': 8.59.3
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/typescript-estree': 8.59.3(typescript@5.9.3)
+      '@typescript-eslint/visitor-keys': 8.59.3
+      debug: 4.4.3(supports-color@8.1.1)
+      eslint: 9.39.4
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/project-service@8.59.3(typescript@4.9.5)':
     dependencies:
-      '@typescript-eslint/tsconfig-utils': 8.59.0(typescript@4.9.5)
-      '@typescript-eslint/types': 8.59.0
+      '@typescript-eslint/tsconfig-utils': 8.59.3(typescript@4.9.5)
+      '@typescript-eslint/types': 8.59.3
       debug: 4.4.3(supports-color@8.1.1)
       typescript: 4.9.5
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/project-service@8.59.0(typescript@5.9.3)':
+  '@typescript-eslint/project-service@8.59.3(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/tsconfig-utils': 8.59.0(typescript@5.9.3)
-      '@typescript-eslint/types': 8.59.0
+      '@typescript-eslint/tsconfig-utils': 8.59.3(typescript@5.9.3)
+      '@typescript-eslint/types': 8.59.3
       debug: 4.4.3(supports-color@8.1.1)
       typescript: 5.9.3
     transitivePeerDependencies:
@@ -9487,60 +9235,60 @@ snapshots:
       '@typescript-eslint/types': 7.18.0
       '@typescript-eslint/visitor-keys': 7.18.0
 
-  '@typescript-eslint/scope-manager@8.59.0':
+  '@typescript-eslint/scope-manager@8.59.3':
     dependencies:
-      '@typescript-eslint/types': 8.59.0
-      '@typescript-eslint/visitor-keys': 8.59.0
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/visitor-keys': 8.59.3
 
-  '@typescript-eslint/tsconfig-utils@8.59.0(typescript@4.9.5)':
+  '@typescript-eslint/tsconfig-utils@8.59.3(typescript@4.9.5)':
     dependencies:
       typescript: 4.9.5
 
-  '@typescript-eslint/tsconfig-utils@8.59.0(typescript@5.9.3)':
+  '@typescript-eslint/tsconfig-utils@8.59.3(typescript@5.9.3)':
     dependencies:
       typescript: 5.9.3
 
-  '@typescript-eslint/type-utils@5.62.0(eslint@8.57.1)(typescript@4.9.5)':
+  '@typescript-eslint/type-utils@5.62.0(eslint@9.39.4)(typescript@4.9.5)':
     dependencies:
       '@typescript-eslint/typescript-estree': 5.62.0(typescript@4.9.5)
-      '@typescript-eslint/utils': 5.62.0(eslint@8.57.1)(typescript@4.9.5)
+      '@typescript-eslint/utils': 5.62.0(eslint@9.39.4)(typescript@4.9.5)
       debug: 4.4.3(supports-color@8.1.1)
-      eslint: 8.57.1
+      eslint: 9.39.4
       tsutils: 3.21.0(typescript@4.9.5)
     optionalDependencies:
       typescript: 4.9.5
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/type-utils@5.62.0(eslint@8.57.1)(typescript@5.9.3)':
+  '@typescript-eslint/type-utils@5.62.0(eslint@9.39.4)(typescript@5.9.3)':
     dependencies:
       '@typescript-eslint/typescript-estree': 5.62.0(typescript@5.9.3)
-      '@typescript-eslint/utils': 5.62.0(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/utils': 5.62.0(eslint@9.39.4)(typescript@5.9.3)
       debug: 4.4.3(supports-color@8.1.1)
-      eslint: 8.57.1
+      eslint: 9.39.4
       tsutils: 3.21.0(typescript@5.9.3)
     optionalDependencies:
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/type-utils@6.21.0(eslint@8.57.1)(typescript@5.9.3)':
+  '@typescript-eslint/type-utils@6.21.0(eslint@9.39.4)(typescript@5.9.3)':
     dependencies:
       '@typescript-eslint/typescript-estree': 6.21.0(typescript@5.9.3)
-      '@typescript-eslint/utils': 6.21.0(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/utils': 6.21.0(eslint@9.39.4)(typescript@5.9.3)
       debug: 4.4.3(supports-color@8.1.1)
-      eslint: 8.57.1
+      eslint: 9.39.4
       ts-api-utils: 1.4.3(typescript@5.9.3)
     optionalDependencies:
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/type-utils@8.59.0(eslint@8.57.1)(typescript@4.9.5)':
+  '@typescript-eslint/type-utils@8.59.3(eslint@8.57.1)(typescript@4.9.5)':
     dependencies:
-      '@typescript-eslint/types': 8.59.0
-      '@typescript-eslint/typescript-estree': 8.59.0(typescript@4.9.5)
-      '@typescript-eslint/utils': 8.59.0(eslint@8.57.1)(typescript@4.9.5)
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/typescript-estree': 8.59.3(typescript@4.9.5)
+      '@typescript-eslint/utils': 8.59.3(eslint@8.57.1)(typescript@4.9.5)
       debug: 4.4.3(supports-color@8.1.1)
       eslint: 8.57.1
       ts-api-utils: 2.5.0(typescript@4.9.5)
@@ -9548,11 +9296,11 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/type-utils@8.59.0(eslint@8.57.1)(typescript@5.9.3)':
+  '@typescript-eslint/type-utils@8.59.3(eslint@8.57.1)(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/types': 8.59.0
-      '@typescript-eslint/typescript-estree': 8.59.0(typescript@5.9.3)
-      '@typescript-eslint/utils': 8.59.0(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/typescript-estree': 8.59.3(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.59.3(eslint@8.57.1)(typescript@5.9.3)
       debug: 4.4.3(supports-color@8.1.1)
       eslint: 8.57.1
       ts-api-utils: 2.5.0(typescript@5.9.3)
@@ -9560,13 +9308,37 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  '@typescript-eslint/type-utils@8.59.3(eslint@9.39.4)(typescript@4.9.5)':
+    dependencies:
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/typescript-estree': 8.59.3(typescript@4.9.5)
+      '@typescript-eslint/utils': 8.59.3(eslint@9.39.4)(typescript@4.9.5)
+      debug: 4.4.3(supports-color@8.1.1)
+      eslint: 9.39.4
+      ts-api-utils: 2.5.0(typescript@4.9.5)
+      typescript: 4.9.5
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/type-utils@8.59.3(eslint@9.39.4)(typescript@5.9.3)':
+    dependencies:
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/typescript-estree': 8.59.3(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.59.3(eslint@9.39.4)(typescript@5.9.3)
+      debug: 4.4.3(supports-color@8.1.1)
+      eslint: 9.39.4
+      ts-api-utils: 2.5.0(typescript@5.9.3)
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - supports-color
+
   '@typescript-eslint/types@5.62.0': {}
 
   '@typescript-eslint/types@6.21.0': {}
 
   '@typescript-eslint/types@7.18.0': {}
 
-  '@typescript-eslint/types@8.59.0': {}
+  '@typescript-eslint/types@8.59.3': {}
 
   '@typescript-eslint/typescript-estree@5.62.0(typescript@4.9.5)':
     dependencies:
@@ -9575,7 +9347,7 @@ snapshots:
       debug: 4.4.3(supports-color@8.1.1)
       globby: 11.1.0
       is-glob: 4.0.3
-      semver: 7.7.4
+      semver: 7.8.0
       tsutils: 3.21.0(typescript@4.9.5)
     optionalDependencies:
       typescript: 4.9.5
@@ -9589,7 +9361,7 @@ snapshots:
       debug: 4.4.3(supports-color@8.1.1)
       globby: 11.1.0
       is-glob: 4.0.3
-      semver: 7.7.4
+      semver: 7.8.0
       tsutils: 3.21.0(typescript@5.9.3)
     optionalDependencies:
       typescript: 5.9.3
@@ -9604,7 +9376,7 @@ snapshots:
       globby: 11.1.0
       is-glob: 4.0.3
       minimatch: 9.0.3
-      semver: 7.7.4
+      semver: 7.8.0
       ts-api-utils: 1.4.3(typescript@5.9.3)
     optionalDependencies:
       typescript: 5.9.3
@@ -9619,120 +9391,142 @@ snapshots:
       globby: 11.1.0
       is-glob: 4.0.3
       minimatch: 9.0.9
-      semver: 7.7.4
+      semver: 7.8.0
       ts-api-utils: 1.4.3(typescript@5.9.3)
     optionalDependencies:
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/typescript-estree@8.59.0(typescript@4.9.5)':
+  '@typescript-eslint/typescript-estree@8.59.3(typescript@4.9.5)':
     dependencies:
-      '@typescript-eslint/project-service': 8.59.0(typescript@4.9.5)
-      '@typescript-eslint/tsconfig-utils': 8.59.0(typescript@4.9.5)
-      '@typescript-eslint/types': 8.59.0
-      '@typescript-eslint/visitor-keys': 8.59.0
+      '@typescript-eslint/project-service': 8.59.3(typescript@4.9.5)
+      '@typescript-eslint/tsconfig-utils': 8.59.3(typescript@4.9.5)
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/visitor-keys': 8.59.3
       debug: 4.4.3(supports-color@8.1.1)
       minimatch: 10.2.5
-      semver: 7.7.4
+      semver: 7.8.0
       tinyglobby: 0.2.16
       ts-api-utils: 2.5.0(typescript@4.9.5)
       typescript: 4.9.5
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/typescript-estree@8.59.0(typescript@5.9.3)':
+  '@typescript-eslint/typescript-estree@8.59.3(typescript@5.9.3)':
     dependencies:
-      '@typescript-eslint/project-service': 8.59.0(typescript@5.9.3)
-      '@typescript-eslint/tsconfig-utils': 8.59.0(typescript@5.9.3)
-      '@typescript-eslint/types': 8.59.0
-      '@typescript-eslint/visitor-keys': 8.59.0
+      '@typescript-eslint/project-service': 8.59.3(typescript@5.9.3)
+      '@typescript-eslint/tsconfig-utils': 8.59.3(typescript@5.9.3)
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/visitor-keys': 8.59.3
       debug: 4.4.3(supports-color@8.1.1)
       minimatch: 10.2.5
-      semver: 7.7.4
+      semver: 7.8.0
       tinyglobby: 0.2.16
       ts-api-utils: 2.5.0(typescript@5.9.3)
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/utils@5.62.0(eslint@8.57.1)(typescript@4.9.5)':
+  '@typescript-eslint/utils@5.62.0(eslint@9.39.4)(typescript@4.9.5)':
     dependencies:
-      '@eslint-community/eslint-utils': 4.9.1(eslint@8.57.1)
+      '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.4)
       '@types/json-schema': 7.0.15
       '@types/semver': 7.7.1
       '@typescript-eslint/scope-manager': 5.62.0
       '@typescript-eslint/types': 5.62.0
       '@typescript-eslint/typescript-estree': 5.62.0(typescript@4.9.5)
-      eslint: 8.57.1
+      eslint: 9.39.4
       eslint-scope: 5.1.1
-      semver: 7.7.4
+      semver: 7.8.0
     transitivePeerDependencies:
       - supports-color
       - typescript
 
-  '@typescript-eslint/utils@5.62.0(eslint@8.57.1)(typescript@5.9.3)':
+  '@typescript-eslint/utils@5.62.0(eslint@9.39.4)(typescript@5.9.3)':
     dependencies:
-      '@eslint-community/eslint-utils': 4.9.1(eslint@8.57.1)
+      '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.4)
       '@types/json-schema': 7.0.15
       '@types/semver': 7.7.1
       '@typescript-eslint/scope-manager': 5.62.0
       '@typescript-eslint/types': 5.62.0
       '@typescript-eslint/typescript-estree': 5.62.0(typescript@5.9.3)
-      eslint: 8.57.1
+      eslint: 9.39.4
       eslint-scope: 5.1.1
-      semver: 7.7.4
+      semver: 7.8.0
     transitivePeerDependencies:
       - supports-color
       - typescript
 
-  '@typescript-eslint/utils@6.21.0(eslint@8.57.1)(typescript@5.9.3)':
+  '@typescript-eslint/utils@6.21.0(eslint@9.39.4)(typescript@5.9.3)':
     dependencies:
-      '@eslint-community/eslint-utils': 4.9.1(eslint@8.57.1)
+      '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.4)
       '@types/json-schema': 7.0.15
       '@types/semver': 7.7.1
       '@typescript-eslint/scope-manager': 6.21.0
       '@typescript-eslint/types': 6.21.0
       '@typescript-eslint/typescript-estree': 6.21.0(typescript@5.9.3)
-      eslint: 8.57.1
-      semver: 7.7.4
+      eslint: 9.39.4
+      semver: 7.8.0
     transitivePeerDependencies:
       - supports-color
       - typescript
 
-  '@typescript-eslint/utils@7.18.0(eslint@8.57.1)(typescript@5.9.3)':
+  '@typescript-eslint/utils@7.18.0(eslint@9.39.4)(typescript@5.9.3)':
     dependencies:
-      '@eslint-community/eslint-utils': 4.9.1(eslint@8.57.1)
+      '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.4)
       '@typescript-eslint/scope-manager': 7.18.0
       '@typescript-eslint/types': 7.18.0
       '@typescript-eslint/typescript-estree': 7.18.0(typescript@5.9.3)
-      eslint: 8.57.1
+      eslint: 9.39.4
     transitivePeerDependencies:
       - supports-color
       - typescript
 
-  '@typescript-eslint/utils@8.59.0(eslint@8.57.1)(typescript@4.9.5)':
+  '@typescript-eslint/utils@8.59.3(eslint@8.57.1)(typescript@4.9.5)':
     dependencies:
       '@eslint-community/eslint-utils': 4.9.1(eslint@8.57.1)
-      '@typescript-eslint/scope-manager': 8.59.0
-      '@typescript-eslint/types': 8.59.0
-      '@typescript-eslint/typescript-estree': 8.59.0(typescript@4.9.5)
+      '@typescript-eslint/scope-manager': 8.59.3
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/typescript-estree': 8.59.3(typescript@4.9.5)
       eslint: 8.57.1
       typescript: 4.9.5
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/utils@8.59.0(eslint@8.57.1)(typescript@5.9.3)':
+  '@typescript-eslint/utils@8.59.3(eslint@8.57.1)(typescript@5.9.3)':
     dependencies:
       '@eslint-community/eslint-utils': 4.9.1(eslint@8.57.1)
-      '@typescript-eslint/scope-manager': 8.59.0
-      '@typescript-eslint/types': 8.59.0
-      '@typescript-eslint/typescript-estree': 8.59.0(typescript@5.9.3)
+      '@typescript-eslint/scope-manager': 8.59.3
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/typescript-estree': 8.59.3(typescript@5.9.3)
       eslint: 8.57.1
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
+  '@typescript-eslint/utils@8.59.3(eslint@9.39.4)(typescript@4.9.5)':
+    dependencies:
+      '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.4)
+      '@typescript-eslint/scope-manager': 8.59.3
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/typescript-estree': 8.59.3(typescript@4.9.5)
+      eslint: 9.39.4
+      typescript: 4.9.5
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/utils@8.59.3(eslint@9.39.4)(typescript@5.9.3)':
+    dependencies:
+      '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.4)
+      '@typescript-eslint/scope-manager': 8.59.3
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/typescript-estree': 8.59.3(typescript@5.9.3)
+      eslint: 9.39.4
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - supports-color
+
   '@typescript-eslint/visitor-keys@5.62.0':
     dependencies:
       '@typescript-eslint/types': 5.62.0
@@ -9748,12 +9542,12 @@ snapshots:
       '@typescript-eslint/types': 7.18.0
       eslint-visitor-keys: 3.4.3
 
-  '@typescript-eslint/visitor-keys@8.59.0':
+  '@typescript-eslint/visitor-keys@8.59.3':
     dependencies:
-      '@typescript-eslint/types': 8.59.0
+      '@typescript-eslint/types': 8.59.3
       eslint-visitor-keys: 5.0.1
 
-  '@ungap/structured-clone@1.3.0': {}
+  '@ungap/structured-clone@1.3.1': {}
 
   '@unrs/resolver-binding-android-arm-eabi@1.11.1':
     optional: true
@@ -9834,21 +9628,21 @@ snapshots:
       clean-stack: 2.2.0
       indent-string: 4.0.0
 
-  ajv-formats@2.1.1(ajv@8.18.0):
+  ajv-formats@2.1.1(ajv@8.20.0):
     optionalDependencies:
-      ajv: 8.18.0
+      ajv: 8.20.0
 
-  ajv@6.14.0:
+  ajv@6.15.0:
     dependencies:
       fast-deep-equal: 3.1.3
       fast-json-stable-stringify: 2.1.0
       json-schema-traverse: 0.4.1
       uri-js: 4.4.1
 
-  ajv@8.18.0:
+  ajv@8.20.0:
     dependencies:
       fast-deep-equal: 3.1.3
-      fast-uri: 3.1.0
+      fast-uri: 3.1.2
       json-schema-traverse: 1.0.0
       require-from-string: 2.0.2
 
@@ -10082,7 +9876,7 @@ snapshots:
 
   base64-js@1.5.1: {}
 
-  baseline-browser-mapping@2.10.20: {}
+  baseline-browser-mapping@2.10.29: {}
 
   big-json@3.2.0:
     dependencies:
@@ -10114,7 +9908,7 @@ snapshots:
     dependencies:
       balanced-match: 1.0.2
 
-  brace-expansion@5.0.5:
+  brace-expansion@5.0.6:
     dependencies:
       balanced-match: 4.0.4
 
@@ -10130,10 +9924,10 @@ snapshots:
 
   browserslist@4.28.2:
     dependencies:
-      baseline-browser-mapping: 2.10.20
-      caniuse-lite: 1.0.30001790
-      electron-to-chromium: 1.5.343
-      node-releases: 2.0.38
+      baseline-browser-mapping: 2.10.29
+      caniuse-lite: 1.0.30001792
+      electron-to-chromium: 1.5.354
+      node-releases: 2.0.44
       update-browserslist-db: 1.2.3(browserslist@4.28.2)
 
   bs-logger@0.2.6:
@@ -10160,7 +9954,7 @@ snapshots:
 
   builtins@5.1.0:
     dependencies:
-      semver: 7.7.4
+      semver: 7.8.0
 
   cache-point@2.0.0:
     dependencies:
@@ -10215,7 +10009,7 @@ snapshots:
 
   camelcase@6.3.0: {}
 
-  caniuse-lite@1.0.30001790: {}
+  caniuse-lite@1.0.30001792: {}
 
   capital-case@1.0.4:
     dependencies:
@@ -10448,8 +10242,8 @@ snapshots:
 
   conf@10.2.0:
     dependencies:
-      ajv: 8.18.0
-      ajv-formats: 2.1.1(ajv@8.18.0)
+      ajv: 8.20.0
+      ajv-formats: 2.1.1(ajv@8.20.0)
       atomically: 1.7.0
       debounce-fn: 4.0.0
       dot-prop: 6.0.1
@@ -10457,7 +10251,7 @@ snapshots:
       json-schema-typed: 7.0.3
       onetime: 5.1.2
       pkg-up: 3.1.0
-      semver: 7.7.4
+      semver: 7.8.0
 
   config-chain@1.1.13:
     dependencies:
@@ -10691,7 +10485,7 @@ snapshots:
     dependencies:
       jake: 10.9.4
 
-  electron-to-chromium@1.5.343: {}
+  electron-to-chromium@1.5.354: {}
 
   elegant-spinner@1.0.1: {}
 
@@ -10705,7 +10499,7 @@ snapshots:
     dependencies:
       once: 1.4.0
 
-  enhanced-resolve@5.20.1:
+  enhanced-resolve@5.21.3:
     dependencies:
       graceful-fs: 4.2.11
       tapable: 2.3.3
@@ -10804,35 +10598,6 @@ snapshots:
 
   es6-promise@4.2.8: {}
 
-  esbuild@0.27.7:
-    optionalDependencies:
-      '@esbuild/aix-ppc64': 0.27.7
-      '@esbuild/android-arm': 0.27.7
-      '@esbuild/android-arm64': 0.27.7
-      '@esbuild/android-x64': 0.27.7
-      '@esbuild/darwin-arm64': 0.27.7
-      '@esbuild/darwin-x64': 0.27.7
-      '@esbuild/freebsd-arm64': 0.27.7
-      '@esbuild/freebsd-x64': 0.27.7
-      '@esbuild/linux-arm': 0.27.7
-      '@esbuild/linux-arm64': 0.27.7
-      '@esbuild/linux-ia32': 0.27.7
-      '@esbuild/linux-loong64': 0.27.7
-      '@esbuild/linux-mips64el': 0.27.7
-      '@esbuild/linux-ppc64': 0.27.7
-      '@esbuild/linux-riscv64': 0.27.7
-      '@esbuild/linux-s390x': 0.27.7
-      '@esbuild/linux-x64': 0.27.7
-      '@esbuild/netbsd-arm64': 0.27.7
-      '@esbuild/netbsd-x64': 0.27.7
-      '@esbuild/openbsd-arm64': 0.27.7
-      '@esbuild/openbsd-x64': 0.27.7
-      '@esbuild/openharmony-arm64': 0.27.7
-      '@esbuild/sunos-x64': 0.27.7
-      '@esbuild/win32-arm64': 0.27.7
-      '@esbuild/win32-ia32': 0.27.7
-      '@esbuild/win32-x64': 0.27.7
-
   escalade@3.2.0: {}
 
   escape-string-regexp@1.0.5: {}
@@ -10844,18 +10609,23 @@ snapshots:
   eslint-compat-utils@0.5.1(eslint@8.57.1):
     dependencies:
       eslint: 8.57.1
-      semver: 7.7.4
+      semver: 7.8.0
 
-  eslint-config-oclif-typescript@3.1.14(eslint@8.57.1)(typescript@5.9.3):
+  eslint-compat-utils@0.5.1(eslint@9.39.4):
     dependencies:
-      '@typescript-eslint/eslint-plugin': 6.21.0(@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1)(typescript@5.9.3)
-      '@typescript-eslint/parser': 6.21.0(eslint@8.57.1)(typescript@5.9.3)
-      eslint-config-xo-space: 0.35.0(eslint@8.57.1)
-      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0)(eslint@8.57.1)
-      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1)
-      eslint-plugin-mocha: 10.5.0(eslint@8.57.1)
-      eslint-plugin-n: 15.7.0(eslint@8.57.1)
-      eslint-plugin-perfectionist: 2.11.0(eslint@8.57.1)(typescript@5.9.3)
+      eslint: 9.39.4
+      semver: 7.8.0
+
+  eslint-config-oclif-typescript@3.1.14(eslint@9.39.4)(typescript@5.9.3):
+    dependencies:
+      '@typescript-eslint/eslint-plugin': 6.21.0(@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3))(eslint@9.39.4)(typescript@5.9.3)
+      '@typescript-eslint/parser': 6.21.0(eslint@9.39.4)(typescript@5.9.3)
+      eslint-config-xo-space: 0.35.0(eslint@9.39.4)
+      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3))(eslint@9.39.4))(eslint@9.39.4)
+      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1)(eslint@9.39.4)
+      eslint-plugin-mocha: 10.5.0(eslint@9.39.4)
+      eslint-plugin-n: 15.7.0(eslint@9.39.4)
+      eslint-plugin-perfectionist: 2.11.0(eslint@9.39.4)(typescript@5.9.3)
     transitivePeerDependencies:
       - astro-eslint-parser
       - eslint
@@ -10876,25 +10646,34 @@ snapshots:
     transitivePeerDependencies:
       - eslint
 
-  eslint-config-oclif@6.0.159(eslint@8.57.1)(typescript@4.9.5):
+  eslint-config-oclif@5.2.2(eslint@9.39.4):
+    dependencies:
+      eslint-config-xo-space: 0.35.0(eslint@9.39.4)
+      eslint-plugin-mocha: 10.5.0(eslint@9.39.4)
+      eslint-plugin-n: 15.7.0(eslint@9.39.4)
+      eslint-plugin-unicorn: 48.0.1(eslint@9.39.4)
+    transitivePeerDependencies:
+      - eslint
+
+  eslint-config-oclif@6.0.164(eslint@8.57.1)(typescript@4.9.5):
     dependencies:
       '@eslint/compat': 1.4.1(eslint@8.57.1)
       '@eslint/eslintrc': 3.3.5
       '@eslint/js': 9.39.4
       '@stylistic/eslint-plugin': 3.1.0(eslint@8.57.1)(typescript@4.9.5)
-      '@typescript-eslint/eslint-plugin': 8.59.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@4.9.5))(eslint@8.57.1)(typescript@4.9.5)
-      '@typescript-eslint/parser': 8.59.0(eslint@8.57.1)(typescript@4.9.5)
+      '@typescript-eslint/eslint-plugin': 8.59.3(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@4.9.5))(eslint@8.57.1)(typescript@4.9.5)
+      '@typescript-eslint/parser': 8.59.3(eslint@8.57.1)(typescript@4.9.5)
       eslint-config-oclif: 5.2.2(eslint@8.57.1)
       eslint-config-xo: 0.49.0(eslint@8.57.1)
       eslint-config-xo-space: 0.35.0(eslint@8.57.1)
       eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0)(eslint@8.57.1)
-      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@4.9.5))(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1)
+      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@4.9.5))(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1)
       eslint-plugin-jsdoc: 50.8.0(eslint@8.57.1)
       eslint-plugin-mocha: 10.5.0(eslint@8.57.1)
       eslint-plugin-n: 17.24.0(eslint@8.57.1)(typescript@4.9.5)
       eslint-plugin-perfectionist: 4.15.1(eslint@8.57.1)(typescript@4.9.5)
       eslint-plugin-unicorn: 56.0.1(eslint@8.57.1)
-      typescript-eslint: 8.59.0(eslint@8.57.1)(typescript@4.9.5)
+      typescript-eslint: 8.59.3(eslint@8.57.1)(typescript@4.9.5)
     transitivePeerDependencies:
       - eslint
       - eslint-import-resolver-webpack
@@ -10902,25 +10681,77 @@ snapshots:
       - supports-color
       - typescript
 
-  eslint-config-oclif@6.0.159(eslint@8.57.1)(typescript@5.9.3):
+  eslint-config-oclif@6.0.164(eslint@8.57.1)(typescript@5.9.3):
     dependencies:
       '@eslint/compat': 1.4.1(eslint@8.57.1)
       '@eslint/eslintrc': 3.3.5
       '@eslint/js': 9.39.4
       '@stylistic/eslint-plugin': 3.1.0(eslint@8.57.1)(typescript@5.9.3)
-      '@typescript-eslint/eslint-plugin': 8.59.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1)(typescript@5.9.3)
-      '@typescript-eslint/parser': 8.59.0(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/eslint-plugin': 8.59.3(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/parser': 8.59.3(eslint@8.57.1)(typescript@5.9.3)
       eslint-config-oclif: 5.2.2(eslint@8.57.1)
       eslint-config-xo: 0.49.0(eslint@8.57.1)
       eslint-config-xo-space: 0.35.0(eslint@8.57.1)
-      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1)
-      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1)
+      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1)
+      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1)
       eslint-plugin-jsdoc: 50.8.0(eslint@8.57.1)
       eslint-plugin-mocha: 10.5.0(eslint@8.57.1)
       eslint-plugin-n: 17.24.0(eslint@8.57.1)(typescript@5.9.3)
       eslint-plugin-perfectionist: 4.15.1(eslint@8.57.1)(typescript@5.9.3)
       eslint-plugin-unicorn: 56.0.1(eslint@8.57.1)
-      typescript-eslint: 8.59.0(eslint@8.57.1)(typescript@5.9.3)
+      typescript-eslint: 8.59.3(eslint@8.57.1)(typescript@5.9.3)
+    transitivePeerDependencies:
+      - eslint
+      - eslint-import-resolver-webpack
+      - eslint-plugin-import-x
+      - supports-color
+      - typescript
+
+  eslint-config-oclif@6.0.164(eslint@9.39.4)(typescript@4.9.5):
+    dependencies:
+      '@eslint/compat': 1.4.1(eslint@9.39.4)
+      '@eslint/eslintrc': 3.3.5
+      '@eslint/js': 9.39.4
+      '@stylistic/eslint-plugin': 3.1.0(eslint@9.39.4)(typescript@4.9.5)
+      '@typescript-eslint/eslint-plugin': 8.59.3(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@4.9.5))(eslint@9.39.4)(typescript@4.9.5)
+      '@typescript-eslint/parser': 8.59.3(eslint@9.39.4)(typescript@4.9.5)
+      eslint-config-oclif: 5.2.2(eslint@9.39.4)
+      eslint-config-xo: 0.49.0(eslint@9.39.4)
+      eslint-config-xo-space: 0.35.0(eslint@9.39.4)
+      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0)(eslint@9.39.4)
+      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@4.9.5))(eslint-import-resolver-typescript@3.10.1)(eslint@9.39.4)
+      eslint-plugin-jsdoc: 50.8.0(eslint@9.39.4)
+      eslint-plugin-mocha: 10.5.0(eslint@9.39.4)
+      eslint-plugin-n: 17.24.0(eslint@9.39.4)(typescript@4.9.5)
+      eslint-plugin-perfectionist: 4.15.1(eslint@9.39.4)(typescript@4.9.5)
+      eslint-plugin-unicorn: 56.0.1(eslint@9.39.4)
+      typescript-eslint: 8.59.3(eslint@9.39.4)(typescript@4.9.5)
+    transitivePeerDependencies:
+      - eslint
+      - eslint-import-resolver-webpack
+      - eslint-plugin-import-x
+      - supports-color
+      - typescript
+
+  eslint-config-oclif@6.0.164(eslint@9.39.4)(typescript@5.9.3):
+    dependencies:
+      '@eslint/compat': 1.4.1(eslint@9.39.4)
+      '@eslint/eslintrc': 3.3.5
+      '@eslint/js': 9.39.4
+      '@stylistic/eslint-plugin': 3.1.0(eslint@9.39.4)(typescript@5.9.3)
+      '@typescript-eslint/eslint-plugin': 8.59.3(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@5.9.3))(eslint@9.39.4)(typescript@5.9.3)
+      '@typescript-eslint/parser': 8.59.3(eslint@9.39.4)(typescript@5.9.3)
+      eslint-config-oclif: 5.2.2(eslint@9.39.4)
+      eslint-config-xo: 0.49.0(eslint@9.39.4)
+      eslint-config-xo-space: 0.35.0(eslint@9.39.4)
+      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3))(eslint@9.39.4))(eslint@9.39.4)
+      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3))(eslint@9.39.4))(eslint@9.39.4))(eslint@9.39.4)
+      eslint-plugin-jsdoc: 50.8.0(eslint@9.39.4)
+      eslint-plugin-mocha: 10.5.0(eslint@9.39.4)
+      eslint-plugin-n: 17.24.0(eslint@9.39.4)(typescript@5.9.3)
+      eslint-plugin-perfectionist: 4.15.1(eslint@9.39.4)(typescript@5.9.3)
+      eslint-plugin-unicorn: 56.0.1(eslint@9.39.4)
+      typescript-eslint: 8.59.3(eslint@9.39.4)(typescript@5.9.3)
     transitivePeerDependencies:
       - eslint
       - eslint-import-resolver-webpack
@@ -10933,10 +10764,20 @@ snapshots:
       eslint: 8.57.1
       eslint-config-xo: 0.44.0(eslint@8.57.1)
 
-  eslint-config-xo@0.44.0(eslint@8.57.1):
+  eslint-config-xo-space@0.35.0(eslint@9.39.4):
+    dependencies:
+      eslint: 9.39.4
+      eslint-config-xo: 0.44.0(eslint@9.39.4)
+
+  eslint-config-xo@0.44.0(eslint@8.57.1):
+    dependencies:
+      confusing-browser-globals: 1.0.11
+      eslint: 8.57.1
+
+  eslint-config-xo@0.44.0(eslint@9.39.4):
     dependencies:
       confusing-browser-globals: 1.0.11
-      eslint: 8.57.1
+      eslint: 9.39.4
 
   eslint-config-xo@0.49.0(eslint@8.57.1):
     dependencies:
@@ -10947,15 +10788,39 @@ snapshots:
       eslint: 8.57.1
       globals: 16.5.0
 
+  eslint-config-xo@0.49.0(eslint@9.39.4):
+    dependencies:
+      '@eslint/css': 0.10.0
+      '@eslint/json': 0.13.2
+      '@stylistic/eslint-plugin': 5.10.0(eslint@9.39.4)
+      confusing-browser-globals: 1.0.11
+      eslint: 9.39.4
+      globals: 16.5.0
+
   eslint-import-resolver-node@0.3.10:
     dependencies:
       debug: 3.2.7
-      is-core-module: 2.16.1
+      is-core-module: 2.16.2
       resolve: 2.0.0-next.6
     transitivePeerDependencies:
       - supports-color
 
-  eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1):
+  eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3))(eslint@9.39.4))(eslint@9.39.4):
+    dependencies:
+      '@nolyfill/is-core-module': 1.0.39
+      debug: 4.4.3(supports-color@8.1.1)
+      eslint: 9.39.4
+      get-tsconfig: 4.14.0
+      is-bun-module: 2.0.0
+      stable-hash: 0.0.5
+      tinyglobby: 0.2.16
+      unrs-resolver: 1.11.1
+    optionalDependencies:
+      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1)(eslint@9.39.4)
+    transitivePeerDependencies:
+      - supports-color
+
+  eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1):
     dependencies:
       '@nolyfill/is-core-module': 1.0.39
       debug: 4.4.3(supports-color@8.1.1)
@@ -10966,7 +10831,7 @@ snapshots:
       tinyglobby: 0.2.16
       unrs-resolver: 1.11.1
     optionalDependencies:
-      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1)
+      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1)
     transitivePeerDependencies:
       - supports-color
 
@@ -10981,40 +10846,77 @@ snapshots:
       tinyglobby: 0.2.16
       unrs-resolver: 1.11.1
     optionalDependencies:
-      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1)
+      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@4.9.5))(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1)
+    transitivePeerDependencies:
+      - supports-color
+
+  eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0)(eslint@9.39.4):
+    dependencies:
+      '@nolyfill/is-core-module': 1.0.39
+      debug: 4.4.3(supports-color@8.1.1)
+      eslint: 9.39.4
+      get-tsconfig: 4.14.0
+      is-bun-module: 2.0.0
+      stable-hash: 0.0.5
+      tinyglobby: 0.2.16
+      unrs-resolver: 1.11.1
+    optionalDependencies:
+      eslint-plugin-import: 2.32.0(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@4.9.5))(eslint-import-resolver-typescript@3.10.1)(eslint@9.39.4)
     transitivePeerDependencies:
       - supports-color
 
-  eslint-module-utils@2.12.1(@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1):
+  eslint-module-utils@2.12.1(@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3))(eslint@9.39.4))(eslint@9.39.4))(eslint@9.39.4):
     dependencies:
       debug: 3.2.7
     optionalDependencies:
-      '@typescript-eslint/parser': 6.21.0(eslint@8.57.1)(typescript@5.9.3)
-      eslint: 8.57.1
+      '@typescript-eslint/parser': 6.21.0(eslint@9.39.4)(typescript@5.9.3)
+      eslint: 9.39.4
       eslint-import-resolver-node: 0.3.10
-      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0)(eslint@8.57.1)
+      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3))(eslint@9.39.4))(eslint@9.39.4)
     transitivePeerDependencies:
       - supports-color
 
-  eslint-module-utils@2.12.1(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@4.9.5))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1):
+  eslint-module-utils@2.12.1(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@4.9.5))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1):
     dependencies:
       debug: 3.2.7
     optionalDependencies:
-      '@typescript-eslint/parser': 8.59.0(eslint@8.57.1)(typescript@4.9.5)
+      '@typescript-eslint/parser': 8.59.3(eslint@8.57.1)(typescript@4.9.5)
       eslint: 8.57.1
       eslint-import-resolver-node: 0.3.10
       eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0)(eslint@8.57.1)
     transitivePeerDependencies:
       - supports-color
 
-  eslint-module-utils@2.12.1(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1):
+  eslint-module-utils@2.12.1(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1):
     dependencies:
       debug: 3.2.7
     optionalDependencies:
-      '@typescript-eslint/parser': 8.59.0(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/parser': 8.59.3(eslint@8.57.1)(typescript@5.9.3)
       eslint: 8.57.1
       eslint-import-resolver-node: 0.3.10
-      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1)
+      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1)
+    transitivePeerDependencies:
+      - supports-color
+
+  eslint-module-utils@2.12.1(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@4.9.5))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1)(eslint@9.39.4):
+    dependencies:
+      debug: 3.2.7
+    optionalDependencies:
+      '@typescript-eslint/parser': 8.59.3(eslint@9.39.4)(typescript@4.9.5)
+      eslint: 9.39.4
+      eslint-import-resolver-node: 0.3.10
+      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0)(eslint@9.39.4)
+    transitivePeerDependencies:
+      - supports-color
+
+  eslint-module-utils@2.12.1(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@5.9.3))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3))(eslint@9.39.4))(eslint@9.39.4))(eslint@9.39.4):
+    dependencies:
+      debug: 3.2.7
+    optionalDependencies:
+      '@typescript-eslint/parser': 8.59.3(eslint@9.39.4)(typescript@5.9.3)
+      eslint: 9.39.4
+      eslint-import-resolver-node: 0.3.10
+      eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3))(eslint@9.39.4))(eslint@9.39.4)
     transitivePeerDependencies:
       - supports-color
 
@@ -11025,13 +10927,26 @@ snapshots:
       eslint: 8.57.1
       eslint-compat-utils: 0.5.1(eslint@8.57.1)
 
+  eslint-plugin-es-x@7.8.0(eslint@9.39.4):
+    dependencies:
+      '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.4)
+      '@eslint-community/regexpp': 4.12.2
+      eslint: 9.39.4
+      eslint-compat-utils: 0.5.1(eslint@9.39.4)
+
   eslint-plugin-es@4.1.0(eslint@8.57.1):
     dependencies:
       eslint: 8.57.1
       eslint-utils: 2.1.0
       regexpp: 3.2.0
 
-  eslint-plugin-import@2.32.0(@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1):
+  eslint-plugin-es@4.1.0(eslint@9.39.4):
+    dependencies:
+      eslint: 9.39.4
+      eslint-utils: 2.1.0
+      regexpp: 3.2.0
+
+  eslint-plugin-import@2.32.0(@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1)(eslint@9.39.4):
     dependencies:
       '@rtsao/scc': 1.1.0
       array-includes: 3.1.9
@@ -11040,11 +10955,11 @@ snapshots:
       array.prototype.flatmap: 1.3.3
       debug: 3.2.7
       doctrine: 2.1.0
-      eslint: 8.57.1
+      eslint: 9.39.4
       eslint-import-resolver-node: 0.3.10
-      eslint-module-utils: 2.12.1(@typescript-eslint/parser@6.21.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1)
+      eslint-module-utils: 2.12.1(@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3))(eslint@9.39.4))(eslint@9.39.4))(eslint@9.39.4)
       hasown: 2.0.3
-      is-core-module: 2.16.1
+      is-core-module: 2.16.2
       is-glob: 4.0.3
       minimatch: 3.1.5
       object.fromentries: 2.0.8
@@ -11054,13 +10969,13 @@ snapshots:
       string.prototype.trimend: 1.0.9
       tsconfig-paths: 3.15.0
     optionalDependencies:
-      '@typescript-eslint/parser': 6.21.0(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/parser': 6.21.0(eslint@9.39.4)(typescript@5.9.3)
     transitivePeerDependencies:
       - eslint-import-resolver-typescript
       - eslint-import-resolver-webpack
       - supports-color
 
-  eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@4.9.5))(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1):
+  eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@4.9.5))(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1):
     dependencies:
       '@rtsao/scc': 1.1.0
       array-includes: 3.1.9
@@ -11071,9 +10986,9 @@ snapshots:
       doctrine: 2.1.0
       eslint: 8.57.1
       eslint-import-resolver-node: 0.3.10
-      eslint-module-utils: 2.12.1(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@4.9.5))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1)
+      eslint-module-utils: 2.12.1(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@4.9.5))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1)(eslint@8.57.1)
       hasown: 2.0.3
-      is-core-module: 2.16.1
+      is-core-module: 2.16.2
       is-glob: 4.0.3
       minimatch: 3.1.5
       object.fromentries: 2.0.8
@@ -11083,13 +10998,13 @@ snapshots:
       string.prototype.trimend: 1.0.9
       tsconfig-paths: 3.15.0
     optionalDependencies:
-      '@typescript-eslint/parser': 8.59.0(eslint@8.57.1)(typescript@4.9.5)
+      '@typescript-eslint/parser': 8.59.3(eslint@8.57.1)(typescript@4.9.5)
     transitivePeerDependencies:
       - eslint-import-resolver-typescript
       - eslint-import-resolver-webpack
       - supports-color
 
-  eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1):
+  eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1):
     dependencies:
       '@rtsao/scc': 1.1.0
       array-includes: 3.1.9
@@ -11100,9 +11015,67 @@ snapshots:
       doctrine: 2.1.0
       eslint: 8.57.1
       eslint-import-resolver-node: 0.3.10
-      eslint-module-utils: 2.12.1(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1)
+      eslint-module-utils: 2.12.1(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@5.9.3))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1))(eslint@8.57.1))(eslint@8.57.1)
+      hasown: 2.0.3
+      is-core-module: 2.16.2
+      is-glob: 4.0.3
+      minimatch: 3.1.5
+      object.fromentries: 2.0.8
+      object.groupby: 1.0.3
+      object.values: 1.2.1
+      semver: 6.3.1
+      string.prototype.trimend: 1.0.9
+      tsconfig-paths: 3.15.0
+    optionalDependencies:
+      '@typescript-eslint/parser': 8.59.3(eslint@8.57.1)(typescript@5.9.3)
+    transitivePeerDependencies:
+      - eslint-import-resolver-typescript
+      - eslint-import-resolver-webpack
+      - supports-color
+
+  eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@4.9.5))(eslint-import-resolver-typescript@3.10.1)(eslint@9.39.4):
+    dependencies:
+      '@rtsao/scc': 1.1.0
+      array-includes: 3.1.9
+      array.prototype.findlastindex: 1.2.6
+      array.prototype.flat: 1.3.3
+      array.prototype.flatmap: 1.3.3
+      debug: 3.2.7
+      doctrine: 2.1.0
+      eslint: 9.39.4
+      eslint-import-resolver-node: 0.3.10
+      eslint-module-utils: 2.12.1(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@4.9.5))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1)(eslint@9.39.4)
+      hasown: 2.0.3
+      is-core-module: 2.16.2
+      is-glob: 4.0.3
+      minimatch: 3.1.5
+      object.fromentries: 2.0.8
+      object.groupby: 1.0.3
+      object.values: 1.2.1
+      semver: 6.3.1
+      string.prototype.trimend: 1.0.9
+      tsconfig-paths: 3.15.0
+    optionalDependencies:
+      '@typescript-eslint/parser': 8.59.3(eslint@9.39.4)(typescript@4.9.5)
+    transitivePeerDependencies:
+      - eslint-import-resolver-typescript
+      - eslint-import-resolver-webpack
+      - supports-color
+
+  eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@5.9.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3))(eslint@9.39.4))(eslint@9.39.4))(eslint@9.39.4):
+    dependencies:
+      '@rtsao/scc': 1.1.0
+      array-includes: 3.1.9
+      array.prototype.findlastindex: 1.2.6
+      array.prototype.flat: 1.3.3
+      array.prototype.flatmap: 1.3.3
+      debug: 3.2.7
+      doctrine: 2.1.0
+      eslint: 9.39.4
+      eslint-import-resolver-node: 0.3.10
+      eslint-module-utils: 2.12.1(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@5.9.3))(eslint-import-resolver-node@0.3.10)(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@6.21.0(eslint@9.39.4)(typescript@5.9.3))(eslint@9.39.4))(eslint@9.39.4))(eslint@9.39.4)
       hasown: 2.0.3
-      is-core-module: 2.16.1
+      is-core-module: 2.16.2
       is-glob: 4.0.3
       minimatch: 3.1.5
       object.fromentries: 2.0.8
@@ -11112,7 +11085,7 @@ snapshots:
       string.prototype.trimend: 1.0.9
       tsconfig-paths: 3.15.0
     optionalDependencies:
-      '@typescript-eslint/parser': 8.59.0(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/parser': 8.59.3(eslint@9.39.4)(typescript@5.9.3)
     transitivePeerDependencies:
       - eslint-import-resolver-typescript
       - eslint-import-resolver-webpack
@@ -11129,7 +11102,23 @@ snapshots:
       espree: 10.4.0
       esquery: 1.7.0
       parse-imports-exports: 0.2.4
-      semver: 7.7.4
+      semver: 7.8.0
+      spdx-expression-parse: 4.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  eslint-plugin-jsdoc@50.8.0(eslint@9.39.4):
+    dependencies:
+      '@es-joy/jsdoccomment': 0.50.2
+      are-docs-informative: 0.0.2
+      comment-parser: 1.4.1
+      debug: 4.4.3(supports-color@8.1.1)
+      escape-string-regexp: 4.0.0
+      eslint: 9.39.4
+      espree: 10.4.0
+      esquery: 1.7.0
+      parse-imports-exports: 0.2.4
+      semver: 7.8.0
       spdx-expression-parse: 4.0.0
     transitivePeerDependencies:
       - supports-color
@@ -11141,6 +11130,13 @@ snapshots:
       globals: 13.24.0
       rambda: 7.5.0
 
+  eslint-plugin-mocha@10.5.0(eslint@9.39.4):
+    dependencies:
+      eslint: 9.39.4
+      eslint-utils: 3.0.0(eslint@9.39.4)
+      globals: 13.24.0
+      rambda: 7.5.0
+
   eslint-plugin-n@15.7.0(eslint@8.57.1):
     dependencies:
       builtins: 5.1.0
@@ -11148,22 +11144,34 @@ snapshots:
       eslint-plugin-es: 4.1.0(eslint@8.57.1)
       eslint-utils: 3.0.0(eslint@8.57.1)
       ignore: 5.3.2
-      is-core-module: 2.16.1
+      is-core-module: 2.16.2
       minimatch: 3.1.5
       resolve: 1.22.12
-      semver: 7.7.4
+      semver: 7.8.0
+
+  eslint-plugin-n@15.7.0(eslint@9.39.4):
+    dependencies:
+      builtins: 5.1.0
+      eslint: 9.39.4
+      eslint-plugin-es: 4.1.0(eslint@9.39.4)
+      eslint-utils: 3.0.0(eslint@9.39.4)
+      ignore: 5.3.2
+      is-core-module: 2.16.2
+      minimatch: 3.1.5
+      resolve: 1.22.12
+      semver: 7.8.0
 
   eslint-plugin-n@17.24.0(eslint@8.57.1)(typescript@4.9.5):
     dependencies:
       '@eslint-community/eslint-utils': 4.9.1(eslint@8.57.1)
-      enhanced-resolve: 5.20.1
+      enhanced-resolve: 5.21.3
       eslint: 8.57.1
       eslint-plugin-es-x: 7.8.0(eslint@8.57.1)
       get-tsconfig: 4.14.0
       globals: 15.15.0
       globrex: 0.1.2
       ignore: 5.3.2
-      semver: 7.7.4
+      semver: 7.8.0
       ts-declaration-location: 1.0.7(typescript@4.9.5)
     transitivePeerDependencies:
       - typescript
@@ -11171,22 +11179,52 @@ snapshots:
   eslint-plugin-n@17.24.0(eslint@8.57.1)(typescript@5.9.3):
     dependencies:
       '@eslint-community/eslint-utils': 4.9.1(eslint@8.57.1)
-      enhanced-resolve: 5.20.1
+      enhanced-resolve: 5.21.3
       eslint: 8.57.1
       eslint-plugin-es-x: 7.8.0(eslint@8.57.1)
       get-tsconfig: 4.14.0
       globals: 15.15.0
       globrex: 0.1.2
       ignore: 5.3.2
-      semver: 7.7.4
+      semver: 7.8.0
       ts-declaration-location: 1.0.7(typescript@5.9.3)
     transitivePeerDependencies:
       - typescript
 
-  eslint-plugin-perfectionist@2.11.0(eslint@8.57.1)(typescript@5.9.3):
+  eslint-plugin-n@17.24.0(eslint@9.39.4)(typescript@4.9.5):
     dependencies:
-      '@typescript-eslint/utils': 7.18.0(eslint@8.57.1)(typescript@5.9.3)
-      eslint: 8.57.1
+      '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.4)
+      enhanced-resolve: 5.21.3
+      eslint: 9.39.4
+      eslint-plugin-es-x: 7.8.0(eslint@9.39.4)
+      get-tsconfig: 4.14.0
+      globals: 15.15.0
+      globrex: 0.1.2
+      ignore: 5.3.2
+      semver: 7.8.0
+      ts-declaration-location: 1.0.7(typescript@4.9.5)
+    transitivePeerDependencies:
+      - typescript
+
+  eslint-plugin-n@17.24.0(eslint@9.39.4)(typescript@5.9.3):
+    dependencies:
+      '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.4)
+      enhanced-resolve: 5.21.3
+      eslint: 9.39.4
+      eslint-plugin-es-x: 7.8.0(eslint@9.39.4)
+      get-tsconfig: 4.14.0
+      globals: 15.15.0
+      globrex: 0.1.2
+      ignore: 5.3.2
+      semver: 7.8.0
+      ts-declaration-location: 1.0.7(typescript@5.9.3)
+    transitivePeerDependencies:
+      - typescript
+
+  eslint-plugin-perfectionist@2.11.0(eslint@9.39.4)(typescript@5.9.3):
+    dependencies:
+      '@typescript-eslint/utils': 7.18.0(eslint@9.39.4)(typescript@5.9.3)
+      eslint: 9.39.4
       minimatch: 9.0.9
       natural-compare-lite: 1.4.0
     transitivePeerDependencies:
@@ -11195,8 +11233,8 @@ snapshots:
 
   eslint-plugin-perfectionist@4.15.1(eslint@8.57.1)(typescript@4.9.5):
     dependencies:
-      '@typescript-eslint/types': 8.59.0
-      '@typescript-eslint/utils': 8.59.0(eslint@8.57.1)(typescript@4.9.5)
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/utils': 8.59.3(eslint@8.57.1)(typescript@4.9.5)
       eslint: 8.57.1
       natural-orderby: 5.0.0
     transitivePeerDependencies:
@@ -11205,14 +11243,34 @@ snapshots:
 
   eslint-plugin-perfectionist@4.15.1(eslint@8.57.1)(typescript@5.9.3):
     dependencies:
-      '@typescript-eslint/types': 8.59.0
-      '@typescript-eslint/utils': 8.59.0(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/utils': 8.59.3(eslint@8.57.1)(typescript@5.9.3)
       eslint: 8.57.1
       natural-orderby: 5.0.0
     transitivePeerDependencies:
       - supports-color
       - typescript
 
+  eslint-plugin-perfectionist@4.15.1(eslint@9.39.4)(typescript@4.9.5):
+    dependencies:
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/utils': 8.59.3(eslint@9.39.4)(typescript@4.9.5)
+      eslint: 9.39.4
+      natural-orderby: 5.0.0
+    transitivePeerDependencies:
+      - supports-color
+      - typescript
+
+  eslint-plugin-perfectionist@4.15.1(eslint@9.39.4)(typescript@5.9.3):
+    dependencies:
+      '@typescript-eslint/types': 8.59.3
+      '@typescript-eslint/utils': 8.59.3(eslint@9.39.4)(typescript@5.9.3)
+      eslint: 9.39.4
+      natural-orderby: 5.0.0
+    transitivePeerDependencies:
+      - supports-color
+      - typescript
+
   eslint-plugin-unicorn@48.0.1(eslint@8.57.1):
     dependencies:
       '@babel/helper-validator-identifier': 7.28.5
@@ -11229,7 +11287,26 @@ snapshots:
       read-pkg-up: 7.0.1
       regexp-tree: 0.1.27
       regjsparser: 0.10.0
-      semver: 7.7.4
+      semver: 7.8.0
+      strip-indent: 3.0.0
+
+  eslint-plugin-unicorn@48.0.1(eslint@9.39.4):
+    dependencies:
+      '@babel/helper-validator-identifier': 7.28.5
+      '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.4)
+      ci-info: 3.9.0
+      clean-regexp: 1.0.0
+      eslint: 9.39.4
+      esquery: 1.7.0
+      indent-string: 4.0.0
+      is-builtin-module: 3.2.1
+      jsesc: 3.1.0
+      lodash: 4.18.1
+      pluralize: 8.0.0
+      read-pkg-up: 7.0.1
+      regexp-tree: 0.1.27
+      regjsparser: 0.10.0
+      semver: 7.8.0
       strip-indent: 3.0.0
 
   eslint-plugin-unicorn@56.0.1(eslint@8.57.1):
@@ -11249,7 +11326,27 @@ snapshots:
       read-pkg-up: 7.0.1
       regexp-tree: 0.1.27
       regjsparser: 0.10.0
-      semver: 7.7.4
+      semver: 7.8.0
+      strip-indent: 3.0.0
+
+  eslint-plugin-unicorn@56.0.1(eslint@9.39.4):
+    dependencies:
+      '@babel/helper-validator-identifier': 7.28.5
+      '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.4)
+      ci-info: 4.4.0
+      clean-regexp: 1.0.0
+      core-js-compat: 3.49.0
+      eslint: 9.39.4
+      esquery: 1.7.0
+      globals: 15.15.0
+      indent-string: 4.0.0
+      is-builtin-module: 3.2.1
+      jsesc: 3.1.0
+      pluralize: 8.0.0
+      read-pkg-up: 7.0.1
+      regexp-tree: 0.1.27
+      regjsparser: 0.10.0
+      semver: 7.8.0
       strip-indent: 3.0.0
 
   eslint-scope@5.1.1:
@@ -11276,6 +11373,11 @@ snapshots:
       eslint: 8.57.1
       eslint-visitor-keys: 2.1.0
 
+  eslint-utils@3.0.0(eslint@9.39.4):
+    dependencies:
+      eslint: 9.39.4
+      eslint-visitor-keys: 2.1.0
+
   eslint-visitor-keys@1.3.0: {}
 
   eslint-visitor-keys@2.1.0: {}
@@ -11295,8 +11397,8 @@ snapshots:
       '@humanwhocodes/config-array': 0.13.0
       '@humanwhocodes/module-importer': 1.0.1
       '@nodelib/fs.walk': 1.2.8
-      '@ungap/structured-clone': 1.3.0
-      ajv: 6.14.0
+      '@ungap/structured-clone': 1.3.1
+      ajv: 6.15.0
       chalk: 4.1.2
       cross-spawn: 7.0.6
       debug: 4.4.3(supports-color@8.1.1)
@@ -11342,8 +11444,8 @@ snapshots:
       '@humanfs/node': 0.16.8
       '@humanwhocodes/module-importer': 1.0.1
       '@humanwhocodes/retry': 0.4.3
-      '@types/estree': 1.0.8
-      ajv: 6.14.0
+      '@types/estree': 1.0.9
+      ajv: 6.15.0
       chalk: 4.1.2
       cross-spawn: 7.0.6
       debug: 4.4.3(supports-color@8.1.1)
@@ -11440,8 +11542,8 @@ snapshots:
     dependencies:
       '@types/chai': 4.3.20
       '@types/lodash': 4.17.24
-      '@types/node': 20.19.39
-      '@types/sinon': 10.0.20
+      '@types/node': 20.19.41
+      '@types/sinon': 17.0.4
       lodash: 4.18.1
       mock-stdin: 1.0.0
       nock: 13.5.6
@@ -11472,17 +11574,19 @@ snapshots:
     dependencies:
       fastest-levenshtein: 1.0.16
 
-  fast-uri@3.1.0: {}
+  fast-uri@3.1.2: {}
 
-  fast-xml-builder@1.1.5:
+  fast-xml-builder@1.2.0:
     dependencies:
       path-expression-matcher: 1.5.0
+      xml-naming: 0.1.0
 
-  fast-xml-parser@5.5.8:
+  fast-xml-parser@5.7.2:
     dependencies:
-      fast-xml-builder: 1.1.5
+      '@nodable/entities': 2.1.0
+      fast-xml-builder: 1.2.0
       path-expression-matcher: 1.5.0
-      strnum: 2.2.3
+      strnum: 2.3.0
 
   fastest-levenshtein@1.0.16: {}
 
@@ -11611,7 +11715,7 @@ snapshots:
 
   fromentries@1.3.2: {}
 
-  fs-extra@11.3.4:
+  fs-extra@11.3.5:
     dependencies:
       graceful-fs: 4.2.11
       jsonfile: 6.2.1
@@ -11932,29 +12036,29 @@ snapshots:
     optionalDependencies:
       '@types/node': 18.19.130
 
-  inquirer@12.11.1(@types/node@20.19.39):
+  inquirer@12.11.1(@types/node@20.19.41):
     dependencies:
       '@inquirer/ansi': 1.0.2
-      '@inquirer/core': 10.3.2(@types/node@20.19.39)
-      '@inquirer/prompts': 7.10.1(@types/node@20.19.39)
-      '@inquirer/type': 3.0.10(@types/node@20.19.39)
+      '@inquirer/core': 10.3.2(@types/node@20.19.41)
+      '@inquirer/prompts': 7.10.1(@types/node@20.19.41)
+      '@inquirer/type': 3.0.10(@types/node@20.19.41)
       mute-stream: 2.0.0
       run-async: 4.0.6
       rxjs: 7.8.2
     optionalDependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
 
-  inquirer@12.11.1(@types/node@22.19.17):
+  inquirer@12.11.1(@types/node@22.19.19):
     dependencies:
       '@inquirer/ansi': 1.0.2
-      '@inquirer/core': 10.3.2(@types/node@22.19.17)
-      '@inquirer/prompts': 7.10.1(@types/node@22.19.17)
-      '@inquirer/type': 3.0.10(@types/node@22.19.17)
+      '@inquirer/core': 10.3.2(@types/node@22.19.19)
+      '@inquirer/prompts': 7.10.1(@types/node@22.19.19)
+      '@inquirer/type': 3.0.10(@types/node@22.19.19)
       mute-stream: 2.0.0
       run-async: 4.0.6
       rxjs: 7.8.2
     optionalDependencies:
-      '@types/node': 22.19.17
+      '@types/node': 22.19.19
 
   inquirer@3.3.0:
     dependencies:
@@ -12026,11 +12130,11 @@ snapshots:
 
   is-bun-module@2.0.0:
     dependencies:
-      semver: 7.7.4
+      semver: 7.8.0
 
   is-callable@1.2.7: {}
 
-  is-core-module@2.16.1:
+  is-core-module@2.16.2:
     dependencies:
       hasown: 2.0.3
 
@@ -12188,7 +12292,7 @@ snapshots:
   istanbul-lib-instrument@5.2.1:
     dependencies:
       '@babel/core': 7.29.0
-      '@babel/parser': 7.29.2
+      '@babel/parser': 7.29.3
       '@istanbuljs/schema': 0.1.6
       istanbul-lib-coverage: 3.2.2
       semver: 6.3.1
@@ -12198,10 +12302,10 @@ snapshots:
   istanbul-lib-instrument@6.0.3:
     dependencies:
       '@babel/core': 7.29.0
-      '@babel/parser': 7.29.2
+      '@babel/parser': 7.29.3
       '@istanbuljs/schema': 0.1.6
       istanbul-lib-coverage: 3.2.2
-      semver: 7.7.4
+      semver: 7.8.0
     transitivePeerDependencies:
       - supports-color
 
@@ -12212,7 +12316,7 @@ snapshots:
       istanbul-lib-coverage: 3.2.2
       p-map: 3.0.0
       rimraf: 3.0.2
-      uuid: 8.3.2
+      uuid: 14.0.0
 
   istanbul-lib-report@3.0.1:
     dependencies:
@@ -12251,7 +12355,7 @@ snapshots:
       '@jest/expect': 29.7.0
       '@jest/test-result': 29.7.0
       '@jest/types': 29.6.3
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
       chalk: 4.1.2
       co: 4.6.0
       dedent: 1.7.2
@@ -12321,7 +12425,7 @@ snapshots:
       - babel-plugin-macros
       - supports-color
 
-  jest-config@29.7.0(@types/node@20.19.39)(ts-node@8.10.2(typescript@5.9.3)):
+  jest-config@29.7.0(@types/node@20.19.41)(ts-node@8.10.2(typescript@5.9.3)):
     dependencies:
       '@babel/core': 7.29.0
       '@jest/test-sequencer': 29.7.0
@@ -12346,7 +12450,7 @@ snapshots:
       slash: 3.0.0
       strip-json-comments: 3.1.1
     optionalDependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
       ts-node: 8.10.2(typescript@5.9.3)
     transitivePeerDependencies:
       - babel-plugin-macros
@@ -12383,7 +12487,7 @@ snapshots:
       '@jest/environment': 29.7.0
       '@jest/fake-timers': 29.7.0
       '@jest/types': 29.6.3
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
       jest-mock: 29.7.0
       jest-util: 29.7.0
 
@@ -12395,7 +12499,7 @@ snapshots:
     dependencies:
       '@jest/types': 29.6.3
       '@types/graceful-fs': 4.1.9
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
       anymatch: 3.1.3
       fb-watchman: 2.0.2
       graceful-fs: 4.2.11
@@ -12434,7 +12538,7 @@ snapshots:
   jest-mock@29.7.0:
     dependencies:
       '@jest/types': 29.6.3
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
       jest-util: 29.7.0
 
   jest-pnp-resolver@1.2.3(jest-resolve@29.7.0):
@@ -12469,7 +12573,7 @@ snapshots:
       '@jest/test-result': 29.7.0
       '@jest/transform': 29.7.0
       '@jest/types': 29.6.3
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
       chalk: 4.1.2
       emittery: 0.13.1
       graceful-fs: 4.2.11
@@ -12497,7 +12601,7 @@ snapshots:
       '@jest/test-result': 29.7.0
       '@jest/transform': 29.7.0
       '@jest/types': 29.6.3
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
       chalk: 4.1.2
       cjs-module-lexer: 1.4.3
       collect-v8-coverage: 1.0.3
@@ -12536,14 +12640,14 @@ snapshots:
       jest-util: 29.7.0
       natural-compare: 1.4.0
       pretty-format: 29.7.0
-      semver: 7.7.4
+      semver: 7.8.0
     transitivePeerDependencies:
       - supports-color
 
   jest-util@29.7.0:
     dependencies:
       '@jest/types': 29.6.3
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
       chalk: 4.1.2
       ci-info: 3.9.0
       graceful-fs: 4.2.11
@@ -12562,7 +12666,7 @@ snapshots:
     dependencies:
       '@jest/test-result': 29.7.0
       '@jest/types': 29.6.3
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
       ansi-escapes: 4.3.2
       chalk: 4.1.2
       emittery: 0.13.1
@@ -12571,7 +12675,7 @@ snapshots:
 
   jest-worker@29.7.0:
     dependencies:
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
       jest-util: 29.7.0
       merge-stream: 2.0.0
       supports-color: 8.1.1
@@ -12641,7 +12745,7 @@ snapshots:
 
   jsdoc@4.0.5:
     dependencies:
-      '@babel/parser': 7.29.2
+      '@babel/parser': 7.29.3
       '@jsdoc/salty': 0.2.12
       '@types/markdown-it': 14.1.2
       bluebird: 3.7.2
@@ -12847,7 +12951,7 @@ snapshots:
 
   lru-cache@10.4.3: {}
 
-  lru-cache@11.3.5: {}
+  lru-cache@11.3.6: {}
 
   lru-cache@5.1.1:
     dependencies:
@@ -12859,7 +12963,7 @@ snapshots:
 
   make-dir@4.0.0:
     dependencies:
-      semver: 7.7.4
+      semver: 7.8.0
 
   make-error@1.3.6: {}
 
@@ -12920,7 +13024,7 @@ snapshots:
 
   minimatch@10.2.5:
     dependencies:
-      brace-expansion: 5.0.5
+      brace-expansion: 5.0.6
 
   minimatch@3.1.5:
     dependencies:
@@ -12954,6 +13058,8 @@ snapshots:
 
   mkdirp@1.0.4: {}
 
+  mkdirp@2.1.6: {}
+
   mocha@10.8.2:
     dependencies:
       ansi-colors: 4.1.3
@@ -13035,7 +13141,7 @@ snapshots:
     dependencies:
       process-on-spawn: 1.1.0
 
-  node-releases@2.0.38: {}
+  node-releases@2.0.44: {}
 
   normalize-package-data@2.5.0:
     dependencies:
@@ -13047,7 +13153,7 @@ snapshots:
   normalize-package-data@6.0.2:
     dependencies:
       hosted-git-info: 7.0.2
-      semver: 7.7.4
+      semver: 7.8.0
       validate-npm-package-license: 3.0.4
 
   normalize-path@3.0.0: {}
@@ -13155,9 +13261,9 @@ snapshots:
       '@inquirer/input': 2.3.0
       '@inquirer/select': 2.5.0
       '@oclif/core': 4.9.0
-      '@oclif/plugin-help': 6.2.44
-      '@oclif/plugin-not-found': 3.2.80(@types/node@14.18.63)
-      '@oclif/plugin-warn-if-update-available': 3.1.60
+      '@oclif/plugin-help': 6.2.48
+      '@oclif/plugin-not-found': 3.2.85(@types/node@14.18.63)
+      '@oclif/plugin-warn-if-update-available': 3.1.64
       ansis: 3.17.0
       async-retry: 1.3.3
       change-case: 4.1.2
@@ -13169,7 +13275,7 @@ snapshots:
       got: 13.0.0
       lodash: 4.18.1
       normalize-package-data: 6.0.2
-      semver: 7.7.4
+      semver: 7.8.0
       sort-package-json: 2.15.1
       tiny-jsonc: 1.0.2
       validate-npm-package-name: 5.0.1
@@ -13186,9 +13292,9 @@ snapshots:
       '@inquirer/input': 2.3.0
       '@inquirer/select': 2.5.0
       '@oclif/core': 4.9.0
-      '@oclif/plugin-help': 6.2.44
-      '@oclif/plugin-not-found': 3.2.80(@types/node@18.19.130)
-      '@oclif/plugin-warn-if-update-available': 3.1.60
+      '@oclif/plugin-help': 6.2.48
+      '@oclif/plugin-not-found': 3.2.85(@types/node@18.19.130)
+      '@oclif/plugin-warn-if-update-available': 3.1.64
       ansis: 3.17.0
       async-retry: 1.3.3
       change-case: 4.1.2
@@ -13200,7 +13306,7 @@ snapshots:
       got: 13.0.0
       lodash: 4.18.1
       normalize-package-data: 6.0.2
-      semver: 7.7.4
+      semver: 7.8.0
       sort-package-json: 2.15.1
       tiny-jsonc: 1.0.2
       validate-npm-package-name: 5.0.1
@@ -13209,7 +13315,7 @@ snapshots:
       - aws-crt
       - supports-color
 
-  oclif@4.23.0(@types/node@20.19.39):
+  oclif@4.23.0(@types/node@20.19.41):
     dependencies:
       '@aws-sdk/client-cloudfront': 3.1009.0
       '@aws-sdk/client-s3': 3.1014.0
@@ -13217,9 +13323,9 @@ snapshots:
       '@inquirer/input': 2.3.0
       '@inquirer/select': 2.5.0
       '@oclif/core': 4.9.0
-      '@oclif/plugin-help': 6.2.44
-      '@oclif/plugin-not-found': 3.2.80(@types/node@20.19.39)
-      '@oclif/plugin-warn-if-update-available': 3.1.60
+      '@oclif/plugin-help': 6.2.48
+      '@oclif/plugin-not-found': 3.2.85(@types/node@20.19.41)
+      '@oclif/plugin-warn-if-update-available': 3.1.64
       ansis: 3.17.0
       async-retry: 1.3.3
       change-case: 4.1.2
@@ -13231,7 +13337,7 @@ snapshots:
       got: 13.0.0
       lodash: 4.18.1
       normalize-package-data: 6.0.2
-      semver: 7.7.4
+      semver: 7.8.0
       sort-package-json: 2.15.1
       tiny-jsonc: 1.0.2
       validate-npm-package-name: 5.0.1
@@ -13240,7 +13346,7 @@ snapshots:
       - aws-crt
       - supports-color
 
-  oclif@4.23.0(@types/node@22.19.17):
+  oclif@4.23.0(@types/node@22.19.19):
     dependencies:
       '@aws-sdk/client-cloudfront': 3.1009.0
       '@aws-sdk/client-s3': 3.1014.0
@@ -13248,9 +13354,9 @@ snapshots:
       '@inquirer/input': 2.3.0
       '@inquirer/select': 2.5.0
       '@oclif/core': 4.9.0
-      '@oclif/plugin-help': 6.2.44
-      '@oclif/plugin-not-found': 3.2.80(@types/node@22.19.17)
-      '@oclif/plugin-warn-if-update-available': 3.1.60
+      '@oclif/plugin-help': 6.2.48
+      '@oclif/plugin-not-found': 3.2.85(@types/node@22.19.19)
+      '@oclif/plugin-warn-if-update-available': 3.1.64
       ansis: 3.17.0
       async-retry: 1.3.3
       change-case: 4.1.2
@@ -13262,7 +13368,7 @@ snapshots:
       got: 13.0.0
       lodash: 4.18.1
       normalize-package-data: 6.0.2
-      semver: 7.7.4
+      semver: 7.8.0
       sort-package-json: 2.15.1
       tiny-jsonc: 1.0.2
       validate-npm-package-name: 5.0.1
@@ -13424,7 +13530,7 @@ snapshots:
 
   path-scurry@2.0.2:
     dependencies:
-      lru-cache: 11.3.5
+      lru-cache: 11.3.6
       minipass: 7.1.3
 
   path-to-regexp@6.3.0: {}
@@ -13451,7 +13557,7 @@ snapshots:
 
   pluralize@8.0.0: {}
 
-  pnpm@10.33.0: {}
+  pnpm@10.33.4: {}
 
   possible-typed-array-names@1.1.0: {}
 
@@ -13674,14 +13780,14 @@ snapshots:
   resolve@1.22.12:
     dependencies:
       es-errors: 1.3.0
-      is-core-module: 2.16.1
+      is-core-module: 2.16.2
       path-parse: 1.0.7
       supports-preserve-symlinks-flag: 1.0.0
 
   resolve@2.0.0-next.6:
     dependencies:
       es-errors: 1.3.0
-      is-core-module: 2.16.1
+      is-core-module: 2.16.2
       node-exports-info: 1.6.0
       object-keys: 1.1.1
       path-parse: 1.0.7
@@ -13777,7 +13883,7 @@ snapshots:
 
   semver@6.3.1: {}
 
-  semver@7.7.4: {}
+  semver@7.8.0: {}
 
   sentence-case@3.0.4:
     dependencies:
@@ -13881,7 +13987,7 @@ snapshots:
   sinon@21.1.2:
     dependencies:
       '@sinonjs/commons': 3.0.1
-      '@sinonjs/fake-timers': 15.3.2
+      '@sinonjs/fake-timers': 15.4.0
       '@sinonjs/samsam': 10.0.2
       diff: 8.0.4
 
@@ -13919,7 +14025,7 @@ snapshots:
       get-stdin: 9.0.0
       git-hooks-list: 3.2.0
       is-plain-obj: 4.1.0
-      semver: 7.7.4
+      semver: 7.8.0
       sort-object-keys: 1.1.3
       tinyglobby: 0.2.16
 
@@ -14083,7 +14189,7 @@ snapshots:
 
   strip-json-comments@3.1.1: {}
 
-  strnum@2.2.3: {}
+  strnum@2.3.0: {}
 
   supports-color@2.0.0: {}
 
@@ -14118,7 +14224,7 @@ snapshots:
 
   tapable@2.3.3: {}
 
-  tar@7.5.13:
+  tar@7.5.15:
     dependencies:
       '@isaacs/fs-minipass': 4.0.1
       chownr: 3.0.0
@@ -14216,7 +14322,7 @@ snapshots:
       json5: 2.2.3
       lodash.memoize: 4.1.2
       make-error: 1.3.6
-      semver: 7.7.4
+      semver: 7.8.0
       type-fest: 4.41.0
       typescript: 5.9.3
       yargs-parser: 21.1.1
@@ -14263,14 +14369,32 @@ snapshots:
       v8-compile-cache-lib: 3.0.1
       yn: 3.1.1
 
-  ts-node@10.9.2(@types/node@20.19.39)(typescript@5.9.3):
+  ts-node@10.9.2(@types/node@20.19.41)(typescript@4.9.5):
+    dependencies:
+      '@cspotcode/source-map-support': 0.8.1
+      '@tsconfig/node10': 1.0.12
+      '@tsconfig/node12': 1.0.11
+      '@tsconfig/node14': 1.0.3
+      '@tsconfig/node16': 1.0.4
+      '@types/node': 20.19.41
+      acorn: 8.16.0
+      acorn-walk: 8.3.5
+      arg: 4.1.3
+      create-require: 1.1.1
+      diff: 4.0.4
+      make-error: 1.3.6
+      typescript: 4.9.5
+      v8-compile-cache-lib: 3.0.1
+      yn: 3.1.1
+
+  ts-node@10.9.2(@types/node@20.19.41)(typescript@5.9.3):
     dependencies:
       '@cspotcode/source-map-support': 0.8.1
       '@tsconfig/node10': 1.0.12
       '@tsconfig/node12': 1.0.11
       '@tsconfig/node14': 1.0.3
       '@tsconfig/node16': 1.0.4
-      '@types/node': 20.19.39
+      '@types/node': 20.19.41
       acorn: 8.16.0
       acorn-walk: 8.3.5
       arg: 4.1.3
@@ -14281,14 +14405,14 @@ snapshots:
       v8-compile-cache-lib: 3.0.1
       yn: 3.1.1
 
-  ts-node@10.9.2(@types/node@22.19.17)(typescript@4.9.5):
+  ts-node@10.9.2(@types/node@22.19.19)(typescript@4.9.5):
     dependencies:
       '@cspotcode/source-map-support': 0.8.1
       '@tsconfig/node10': 1.0.12
       '@tsconfig/node12': 1.0.11
       '@tsconfig/node14': 1.0.3
       '@tsconfig/node16': 1.0.4
-      '@types/node': 22.19.17
+      '@types/node': 22.19.19
       acorn: 8.16.0
       acorn-walk: 8.3.5
       arg: 4.1.3
@@ -14329,13 +14453,6 @@ snapshots:
       tslib: 1.14.1
       typescript: 5.9.3
 
-  tsx@4.21.0:
-    dependencies:
-      esbuild: 0.27.7
-      get-tsconfig: 4.14.0
-    optionalDependencies:
-      fsevents: 2.3.3
-
   tty-table@4.2.3:
     dependencies:
       chalk: 4.1.2
@@ -14418,28 +14535,50 @@ snapshots:
 
   typedarray@0.0.6: {}
 
-  typescript-eslint@8.59.0(eslint@8.57.1)(typescript@4.9.5):
+  typescript-eslint@8.59.3(eslint@8.57.1)(typescript@4.9.5):
     dependencies:
-      '@typescript-eslint/eslint-plugin': 8.59.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@4.9.5))(eslint@8.57.1)(typescript@4.9.5)
-      '@typescript-eslint/parser': 8.59.0(eslint@8.57.1)(typescript@4.9.5)
-      '@typescript-eslint/typescript-estree': 8.59.0(typescript@4.9.5)
-      '@typescript-eslint/utils': 8.59.0(eslint@8.57.1)(typescript@4.9.5)
+      '@typescript-eslint/eslint-plugin': 8.59.3(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@4.9.5))(eslint@8.57.1)(typescript@4.9.5)
+      '@typescript-eslint/parser': 8.59.3(eslint@8.57.1)(typescript@4.9.5)
+      '@typescript-eslint/typescript-estree': 8.59.3(typescript@4.9.5)
+      '@typescript-eslint/utils': 8.59.3(eslint@8.57.1)(typescript@4.9.5)
       eslint: 8.57.1
       typescript: 4.9.5
     transitivePeerDependencies:
       - supports-color
 
-  typescript-eslint@8.59.0(eslint@8.57.1)(typescript@5.9.3):
+  typescript-eslint@8.59.3(eslint@8.57.1)(typescript@5.9.3):
     dependencies:
-      '@typescript-eslint/eslint-plugin': 8.59.0(@typescript-eslint/parser@8.59.0(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1)(typescript@5.9.3)
-      '@typescript-eslint/parser': 8.59.0(eslint@8.57.1)(typescript@5.9.3)
-      '@typescript-eslint/typescript-estree': 8.59.0(typescript@5.9.3)
-      '@typescript-eslint/utils': 8.59.0(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/eslint-plugin': 8.59.3(@typescript-eslint/parser@8.59.3(eslint@8.57.1)(typescript@5.9.3))(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/parser': 8.59.3(eslint@8.57.1)(typescript@5.9.3)
+      '@typescript-eslint/typescript-estree': 8.59.3(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.59.3(eslint@8.57.1)(typescript@5.9.3)
       eslint: 8.57.1
       typescript: 5.9.3
     transitivePeerDependencies:
       - supports-color
 
+  typescript-eslint@8.59.3(eslint@9.39.4)(typescript@4.9.5):
+    dependencies:
+      '@typescript-eslint/eslint-plugin': 8.59.3(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@4.9.5))(eslint@9.39.4)(typescript@4.9.5)
+      '@typescript-eslint/parser': 8.59.3(eslint@9.39.4)(typescript@4.9.5)
+      '@typescript-eslint/typescript-estree': 8.59.3(typescript@4.9.5)
+      '@typescript-eslint/utils': 8.59.3(eslint@9.39.4)(typescript@4.9.5)
+      eslint: 9.39.4
+      typescript: 4.9.5
+    transitivePeerDependencies:
+      - supports-color
+
+  typescript-eslint@8.59.3(eslint@9.39.4)(typescript@5.9.3):
+    dependencies:
+      '@typescript-eslint/eslint-plugin': 8.59.3(@typescript-eslint/parser@8.59.3(eslint@9.39.4)(typescript@5.9.3))(eslint@9.39.4)(typescript@5.9.3)
+      '@typescript-eslint/parser': 8.59.3(eslint@9.39.4)(typescript@5.9.3)
+      '@typescript-eslint/typescript-estree': 8.59.3(typescript@5.9.3)
+      '@typescript-eslint/utils': 8.59.3(eslint@9.39.4)(typescript@5.9.3)
+      eslint: 9.39.4
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - supports-color
+
   typescript@4.9.5: {}
 
   typescript@5.9.3: {}
@@ -14528,9 +14667,7 @@ snapshots:
       is-typed-array: 1.1.15
       which-typed-array: 1.1.20
 
-  uuid@8.3.2: {}
-
-  uuid@9.0.1: {}
+  uuid@14.0.0: {}
 
   v8-compile-cache-lib@3.0.1: {}
 
@@ -14687,6 +14824,8 @@ snapshots:
 
   xdg-basedir@4.0.0: {}
 
+  xml-naming@0.1.0: {}
+
   xmlcreate@2.0.4: {}
 
   xtend@4.0.2: {}
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index a58ba1cae..ddff153ee 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -4,3 +4,4 @@ overrides:
   tmp: 0.2.4
   follow-redirects: 1.16.0
   axios: 1.15.2
+  uuid: 14.0.0
diff --git a/skills/README.md b/skills/README.md
index 3257d9d50..5b71abe19 100644
--- a/skills/README.md
+++ b/skills/README.md
@@ -1,3 +1 @@
-# Skills – Contentstack CLI plugins
-
-Source of truth for detailed guidance. Read [AGENTS.md](../AGENTS.md) for the skill index, then open the `SKILL.md` that matches your task. Each folder contains `SKILL.md` with YAML frontmatter (`name`, `description`).
+Source of truth for detailed guidance. Read **[AGENTS.md](../../AGENTS.md)** for the skill index, then open the SKILL.md that matches your task. Each folder contains SKILL.md with YAML frontmatter (name, description).