@http-forge/core 0.1.0 → 0.2.0

package/dist/cookie/persistent-cookie-jar.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Persistent Cookie Jar
+ *
+ * Adapts an ICookieService to the ICookieJar interface with write-through caching.
+ *
+ * - Maintains a local in-memory cache reflecting immediate changes (set/delete).
+ * - Allows scripts to read their own cookie modifications within the same execution.
+ * - Batches and persists all changes to the underlying ICookieService after execution.
+ *
+ * Extracted from extension's request-execution/PersistentCookieJar.ts.
+ */
+import { Cookie, IAsyncCookieService, ICookieService } from './interfaces';
+import { ICookieJar } from '../script/interfaces';
+export declare class PersistentCookieJar implements ICookieJar {
+    private cookieService;
+    /** Local cache that reflects script modifications */
+    private localCache;
+    /** Track pending operations to batch them after script execution */
+    private pendingOperations;
+    constructor(cookieService: ICookieService | IAsyncCookieService);
+    get(name: string, domain?: string): Cookie | undefined;
+    has(name: string, domain?: string): boolean;
+    set(cookie: Cookie): void;
+    delete(name: string, domain?: string, path?: string): boolean;
+    getAll(domain?: string): Cookie[];
+    getCookiesForDomain(domain: string): Cookie[];
+    setCookiesFromResponse(url: string, headers: Record<string, string | string[]>): Promise<void>;
+    getCookieHeader(url: string): string | undefined;
+    clear(): void;
+    /**
+     * Flush all pending cookie operations to the underlying service.
+     * Should be called after script execution completes.
+     */
+    flush(): Promise<void>;
+}

package/dist/environment/environment-config-service.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Environment Configuration Service
+ *
+ * Platform-agnostic — uses IKeyValueStore for persistence instead of
+ * VS Code's workspaceState/globalState.
+ */
+import { IEnvironmentConfigService, ImportedEnvironment, LocalConfig, ResolvedEnvironment, SharedConfig } from './interfaces';
+import { IKeyValueStore } from '../types/platform';
+import { IConfigService } from '../config';
+export declare class EnvironmentConfigService implements IEnvironmentConfigService {
+    private workspaceFolder;
+    private workspaceStore;
+    private configService;
+    private environmentsPath;
+    private sharedConfigPath;
+    private localConfigPath;
+    private historiesPath;
+    private sharedConfig;
+    private localConfig;
+    private selectedEnvironment;
+    /**
+     * In-memory Local Values for variables (not persisted)
+     * These are set via forge.*.set() in scripts and override file values
+     * Cleared when the process exits
+     */
+    private localGlobalValues;
+    private localEnvironmentValues;
+    constructor(workspaceFolder: string, workspaceStore: IKeyValueStore, configService: IConfigService);
+    getWorkspaceFolder(): string;
+    getRootPath(): string;
+    loadConfigs(): void;
+    getSharedConfig(): SharedConfig | null;
+    getLocalConfig(): LocalConfig | null;
+    getEnvironmentNames(): string[];
+    getSelectedEnvironment(): string;
+    setSelectedEnvironment(envName: string): Promise<void>;
+    setEnvironmentVariable(key: string, value: unknown): void;
+    deleteEnvironmentVariable(key: string): void;
+    clearEnvironmentVariables(): void;
+    getEnvironmentVariableLocal(key: string): string | undefined;
+    getEnvironmentVariableLocals(): Record<string, string>;
+    setGlobalVariable(key: string, value: unknown): void;
+    getGlobalVariable(key: string): string | undefined;
+    getGlobalVariableLocal(key: string): string | undefined;
+    getGlobalVariables(): Record<string, string>;
+    getGlobalVariableLocals(): Record<string, string>;
+    deleteGlobalVariable(key: string): void;
+    clearGlobalVariables(): void;
+    private getSessionStateKey;
+    setSessionVariable(key: string, value: unknown): Promise<void>;
+    getSessionVariable(key: string): string | undefined;
+    getSessionVariables(): Record<string, string>;
+    deleteSessionVariable(key: string): Promise<void>;
+    clearSessionVariables(): Promise<void>;
+    hasSessionVariable(key: string): boolean;
+    getResolvedEnvironment(envName?: string): ResolvedEnvironment | null;
+    resolveVariables(input: string, envName?: string): string;
+    exportEnvironmentsToFolder(outDir: string, mergeGlobals?: boolean): void;
+    resolveVariablesWithExtra(input: string, extraVariables: Record<string, string>, envName?: string): string;
+    resolveVariablesInObject<T>(obj: T, envName?: string): T;
+    resolveVariablesInObjectWithExtra<T>(obj: T, extraVariables: Record<string, string>, envName?: string): T;
+    getHistoriesPath(): string;
+    getSharedConfigPath(): string;
+    getLocalConfigPath(): string;
+    getEnvironmentConfigPath(envName: string): string;
+    localConfigExists(): boolean;
+    saveSharedConfig(config: SharedConfig): void;
+    saveLocalConfig(config: LocalConfig): void;
+    importPostmanEnvironmentFile(filePath: string): ImportedEnvironment;
+    saveEnvLocalConfig(envName: string, variables: Record<string, string>): void;
+    getEnvLocalPath(envName: string): string;
+    private isSystemEnvironmentFile;
+    private getEnvLocalConfigPath;
+    private loadFolderConfigs;
+    private saveFolderSharedConfig;
+    reload(): void;
+    getAllEnvironments(): Array<{
+        id: string;
+        name: string;
+        active: boolean;
+        variables: Record<string, string>;
+    }>;
+    setActiveEnvironment(environmentId: string): Promise<void>;
+    createEnvironment(name: string): Promise<void>;
+    deleteEnvironment(environmentId: string): Promise<void>;
+    duplicateEnvironment(environmentId: string, newName: string): Promise<void>;
+    renameEnvironment(environmentId: string, newName: string): Promise<void>;
+    private validateEnvironmentName;
+    private validateEnvironmentExists;
+    private validateEnvironmentNameNotTaken;
+    private validateConfigLoaded;
+    updateEnvironmentVariables(environmentId: string, variables: Record<string, string>): Promise<void>;
+    private loadJsonFile;
+    private saveJsonFile;
+}

package/dist/{services → environment}/environment-resolver.d.ts

@@ -4,7 +4,7 @@
  * Single Responsibility: Resolve environment variables for request execution
  * Dependency Inversion: Implements IEnvironmentStore interface
  */
-import { IEnvironmentStore } from '../interfaces';
+import { IEnvironmentStore } from './interfaces';
 /**
  * Environment definition
  */
@@ -15,9 +15,11 @@ export interface Environment {
     inherits?: string;
 }
 /**
- * Environment configuration
+ * Environment store configuration (for EnvironmentResolver)
+ * Note: Named EnvironmentStoreConfig to avoid conflict with
+ * interfaces/environment-config-service.ts EnvironmentConfig
  */
-export interface EnvironmentConfig {
+export interface EnvironmentStoreConfig {
     /** Global variables (available in all environments) */
     globalVariables?: Record<string, string>;
     /** Environment definitions */
@@ -34,7 +36,7 @@ export declare class EnvironmentResolver implements IEnvironmentStore {
     /** In-memory values */
     private sessionGlobals;
     private sessionEnvironmentValues;
-    constructor(config: EnvironmentConfig);
+    constructor(config: EnvironmentStoreConfig);
     /**
      * Get a single variable value
      */
@@ -88,4 +90,3 @@ export declare class EnvironmentResolver implements IEnvironmentStore {
      */
     static fromVariables(variables: Record<string, string>, name?: string): EnvironmentResolver;
 }
-//# sourceMappingURL=environment-resolver.d.ts.map

package/dist/{services → environment}/forge-env.d.ts

@@ -30,7 +30,7 @@
  * env.get('token');  // 'abc'
  * ```
  */
-import { IEnvironmentStore, IVariableInterpolator } from '../interfaces';
+import { IEnvironmentStore, IVariableInterpolator } from './interfaces';
 import { EnvironmentResolver } from './environment-resolver';
 /**
  * ForgeEnv interface - the public API for environment management
@@ -163,4 +163,3 @@ export declare class ForgeEnv implements IForgeEnv {
      */
     static fromResolver(resolver: EnvironmentResolver): ForgeEnv;
 }
-//# sourceMappingURL=forge-env.d.ts.map

package/dist/environment/interfaces.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Environment Configuration Service Interface
+ *
+ * Interface Segregation: Separated into focused sub-interfaces
+ * Dependency Inversion: Consumers depend on this abstraction
+ */
+/**
+ * Environment configuration structure
+ */
+export interface EnvironmentConfig {
+    description?: string;
+    requiresConfirmation?: boolean;
+    variables?: Record<string, string>;
+}
+/**
+ * Shared configuration file structure
+ */
+export interface SharedConfig {
+    environments: Record<string, EnvironmentConfig>;
+    globalVariables?: Record<string, string>;
+    defaultHeaders?: Record<string, string>;
+}
+/**
+ * Local configuration file structure
+ */
+export interface LocalConfig {
+    credentials?: Record<string, {
+        variables?: Record<string, string>;
+    }>;
+    variables?: Record<string, string>;
+}
+/**
+ * Resolved environment with all inherited values
+ */
+export interface ResolvedEnvironment {
+    name: string;
+    description?: string;
+    requiresConfirmation?: boolean;
+    headers: Record<string, string>;
+    variables: Record<string, string>;
+}
+/**
+ * Representation of an imported environment (from Postman)
+ */
+export interface ImportedEnvironment {
+    name: string;
+    variables: Record<string, string>;
+    description?: string;
+}
+/**
+ * Import operations for environments
+ */
+export interface IEnvironmentImporter {
+    importPostmanEnvironmentFile(filePath: string): ImportedEnvironment | null;
+}
+/**
+ * Read operations for environment configuration
+ */
+export interface IEnvironmentConfigReader {
+    getWorkspaceFolder(): string;
+    getRootPath(): string;
+    getEnvironmentNames(): string[];
+    getSelectedEnvironment(): string;
+    getSharedConfig(): SharedConfig | null;
+    getSharedConfigPath(): string;
+    getLocalConfig(): LocalConfig | null;
+    getLocalConfigPath(): string;
+    getEnvironmentConfigPath(envName: string): string;
+    getEnvLocalPath(envName: string): string;
+    getResolvedEnvironment(envName: string): ResolvedEnvironment | null;
+}
+/**
+ * Write operations for environment configuration
+ */
+export interface IEnvironmentConfigWriter {
+    saveSharedConfig(config: SharedConfig): void;
+    saveLocalConfig(config: LocalConfig): void;
+}
+/**
+ * Environment selection operations
+ */
+export interface IEnvironmentSelector {
+    setSelectedEnvironment(envName: string): Promise<void>;
+}
+/**
+ * Variable resolution operations
+ */
+export interface IVariableResolver {
+    resolveVariables(text: string, envName?: string): string;
+    resolveVariablesWithExtra(text: string, extraVariables: Record<string, string>, envName?: string): string;
+    resolveVariablesInObject<T extends Record<string, any>>(obj: T, envName?: string): T;
+    resolveVariablesInObjectWithExtra<T extends Record<string, any>>(obj: T, extraVariables: Record<string, string>, envName?: string): T;
+}
+/**
+ * Variable management operations (for scripts)
+ */
+export interface IVariableManager {
+    setEnvironmentVariable(key: string, value: unknown): void;
+    deleteEnvironmentVariable(key: string): void;
+    clearEnvironmentVariables(): void;
+    getEnvironmentVariableLocals(): Record<string, string>;
+    setGlobalVariable(key: string, value: unknown): void;
+    getGlobalVariable(key: string): string | undefined;
+    deleteGlobalVariable(key: string): void;
+    clearGlobalVariables(): void;
+    setSessionVariable(key: string, value: unknown): void;
+    deleteSessionVariable(key: string): Promise<void>;
+    clearSessionVariables(): Promise<void>;
+    getSessionVariables(): Record<string, string>;
+    getGlobalVariables(): Record<string, string>;
+}
+/**
+ * Full environment configuration service interface
+ */
+export interface IEnvironmentConfigService extends IEnvironmentConfigReader, IEnvironmentConfigWriter, IEnvironmentSelector, IVariableResolver, IVariableManager {
+    loadConfigs(): void;
+    exportEnvironmentsToFolder(outDir: string, mergeGlobals?: boolean): void;
+}
+/**
+ * Interface for storing and retrieving environment variables.
+ */
+export interface IEnvironmentStore {
+    get(key: string): string | undefined;
+    set(key: string, value: string): void;
+    getAll(): Record<string, string>;
+    getActive(): string | undefined;
+    setActive(name: string): void;
+    getVariables(environmentName?: string): Record<string, string>;
+}
+/**
+ * Interface for interpolating variables in strings.
+ * Handles {{variable}} syntax replacement.
+ * @deprecated Use IVariableResolver for environment-aware resolution
+ */
+export interface IVariableInterpolator {
+    interpolate(input: string, variables: Record<string, string>): string;
+    extractVariables(input: string): string[];
+    interpolateObject<T>(obj: T, variables: Record<string, string>): T;
+}

package/dist/environment/variable-interpolator.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Variable Interpolator / Resolver
+ *
+ * Single Responsibility: Resolve template variables in strings and objects
+ *
+ * Features:
+ * - Regular variable substitution ({{myVar}} → value)
+ * - Dynamic variables ({{$timestamp}}, {{$randomInt(1, 100)}}, etc.)
+ * - Pipe-based filters (Thunder Client-compatible): {{variable | upper | replace("a", "b")}}
+ * - JavaScript expression evaluation: {{price * quantity}}
+ * - Context-aware escaping (avoids breaking quoted strings)
+ * - Extra variables with highest precedence
+ * - Recursive object traversal
+ * - Generic type preservation for object interpolation
+ *
+ * Resolution order (5-step pipeline):
+ * 1. $dynamic variables: {{$guid}}, {{$randomInt(1, 100)}}
+ * 2. Filter chains: {{myVar | upper | substring(0, 5)}}
+ * 3. Simple variable lookup: {{myVar}}
+ * 4. JavaScript expressions: {{price * quantity + 10}}
+ * 5. Return original {{...}} if nothing matched
+ */
+import { IVariableInterpolator } from './interfaces';
+/**
+ * Configuration for variable resolution
+ */
+export interface VariableResolverConfig {
+    globals: Record<string, string>;
+    collectionVariables: Record<string, string>;
+    environmentVariables: Record<string, string>;
+    sessionVariables: Record<string, string>;
+    variables: Record<string, string>;
+}
+/**
+ * Variable Resolver - Resolves {{varName}} patterns in strings and objects
+ * Uses a 5-step pipeline: $dynamic → filter chains → simple lookup → JS expressions → passthrough
+ * Variable precedence: globals > collection > environment > session > request > extra
+ */
+export declare class VariableResolver {
+    private readonly allVariables;
+    constructor(config: VariableResolverConfig);
+    /**
+     * Resolve variables in a string ({{varName}} syntax)
+     * Uses the full 5-step pipeline with optional escaping for quoted strings
+     */
+    resolveString(str: string, escape?: boolean): string;
+    /**
+     * Resolve variables in a string with additional extra variables
+     * Extra variables take highest precedence
+     */
+    resolveStringWithExtra(str: string, extraVariables: Record<string, string>, escape?: boolean): string;
+    /**
+     * Resolve variables in an object recursively
+     */
+    resolveObject(obj: any, escape?: boolean): any;
+    /**
+     * Resolve variables in an object with extra variables
+     */
+    resolveObjectWithExtra(obj: any, extraVariables: Record<string, string>, escape?: boolean): any;
+    /**
+     * Core 5-step resolution pipeline for template content inside {{ }}
+     */
+    private resolveTemplateContent;
+    /**
+     * Resolve the input portion of a filter chain
+     * Handles: @ (no-input), string literals, $dynamic variable, variable name, JS expression
+     */
+    private resolveFilterInput;
+    /**
+     * Escape special characters for string context
+     */
+    private escapeForString;
+    /**
+     * Determine if position is inside a quoted string and which quote type
+     */
+    private getStringContext;
+}
+/**
+ * VariableInterpolator — backward-compatible wrapper around VariableResolver
+ * Implements IVariableInterpolator interface using the 5-step resolution pipeline
+ */
+export declare class VariableInterpolator implements IVariableInterpolator {
+    /**
+     * Replace {{variable}} placeholders with values using the 5-step pipeline
+     * Automatically escapes values when inside quoted strings
+     */
+    interpolate(input: string, variables: Record<string, string>): string;
+    /**
+     * Extract variable names from a string
+     */
+    extractVariables(input: string): string[];
+    /**
+     * Replace variables in all string values of an object (recursive)
+     */
+    interpolateObject<T>(obj: T, variables: Record<string, string>): T;
+}
+/**
+ * Create a variable resolver from configuration
+ */
+export declare function createVariableResolver(config: VariableResolverConfig): VariableResolver;

package/dist/execution/collection-request-executor-interfaces.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Collection Request Executor Interface
+ *
+ * Defines the contract for executing a single collection request with full Postman parity:
+ * - Script execution order: Collection → Folder(s) → Request (pre-request)
+ * - Script execution order: Request → Folder(s) → Collection (post-response)
+ * - Supports nested folder scripts (multiple levels)
+ * - JavaScript variables declared in pre-request are accessible in post-response (shared VM session)
+ */
+import { ExecutionRequest, ExecutionResult } from '../types/types';
+/**
+ * Console output streaming callback
+ */
+export type ConsoleOutputCallback = (output: string[]) => void;
+/**
+ * Collection Request Executor Interface
+ *
+ * Executes a single request within a collection context, with full
+ * pre-request/post-response script chain support.
+ */
+export interface ICollectionRequestExecutor {
+    /**
+     * Execute a request with full Postman parity.
+     *
+     * Flow:
+     *   Collection pre-request → Folder(s) pre-request → Request pre-request
+     *   → HTTP call →
+     *   Request post-response → Folder(s) post-response → Collection post-response
+     *
+     * @param request - The request to execute
+     * @param variables - Current variable context (may include data file variables)
+     * @param signal - Optional AbortSignal for cancellation
+     * @returns ExecutionResult with response, assertions, timing, etc.
+     */
+    execute(request: ExecutionRequest, variables: Record<string, string>, signal?: AbortSignal): Promise<ExecutionResult>;
+}

package/dist/execution/collection-request-executor.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Collection Request Executor
+ *
+ * Executes a single collection request with full Postman parity:
+ * - Script execution order: Collection → Folder(s) → Request (pre-request)
+ * - Script execution order: Request → Folder(s) → Collection (post-response)
+ * - Supports nested folder scripts (multiple levels)
+ * - JavaScript variables declared in pre-request are accessible in post-response (shared VM session)
+ *
+ * Extracted from extension's request-execution/collection-request-executor.ts.
+ * Platform-independent — no vscode dependency.
+ */
+import { ExecutionRequest, ExecutionResult, PreparedRequest, RequestScripts } from '../types/types';
+import { ICookieJar, IScriptExecutor } from '../script/interfaces';
+import { IEnvironmentConfigService } from '../environment/interfaces';
+import { ConsoleOutputCallback, ICollectionRequestExecutor } from './collection-request-executor-interfaces';
+import { IHttpRequestService } from '../http/interfaces';
+import { IRequestPreparer } from './request-preparer-interfaces';
+/**
+ * Enhanced implementation with Postman parity.
+ * Supports: pre-request scripts, post-response scripts, cookies, settings,
+ * collection/folder scripts.
+ */
+export declare class CollectionRequestExecutor implements ICollectionRequestExecutor {
+    private readonly httpService;
+    private readonly scriptExecutor;
+    private readonly envConfigService;
+    private readonly requestPreparer;
+    private readonly environment;
+    private readonly cookieJar?;
+    private readonly collectionScripts?;
+    private readonly folderScriptsChain?;
+    private readonly onConsoleOutput?;
+    private readonly collectionName?;
+    private readonly iteration?;
+    private readonly iterationCount?;
+    constructor(httpService: IHttpRequestService, scriptExecutor: IScriptExecutor, envConfigService: IEnvironmentConfigService, requestPreparer: IRequestPreparer, environment: string, cookieJar?: ICookieJar | undefined, collectionScripts?: RequestScripts | undefined, folderScriptsChain?: (RequestScripts | RequestScripts[]) | undefined, onConsoleOutput?: ConsoleOutputCallback | undefined, collectionName?: string | undefined, iteration?: number | undefined, iterationCount?: number | undefined);
+    /**
+     * Execute a request with full Postman parity.
+     */
+    execute(request: ExecutionRequest, variables: Record<string, string>, signal?: AbortSignal): Promise<ExecutionResult>;
+    protected executeWithSession(request: ExecutionRequest, variables: Record<string, string>, signal: AbortSignal | undefined, startTime: number): Promise<ExecutionResult>;
+    /**
+     * Collect pre-request scripts in order: Collection → Folder(s) → Request
+     */
+    private collectPreRequestScripts;
+    /**
+     * Collect post-response scripts in order: Request → Folder(s) → Collection
+     */
+    private collectPostResponseScripts;
+    /**
+     * Handle execution errors — returns a failed ExecutionResult.
+     *
+     * The response body is set according to `errorBodyFormat`:
+     * - `'text'`  → plain-text error message (default, safe for CLI / headless)
+     * - `'html'`  → styled HTML suitable for a webview Response tab
+     * - `'both'`  → HTML body **and** `error` field with plain-text message
+     *
+     * Protected so subclasses can override error formatting entirely.
+     */
+    protected handleError(request: ExecutionRequest, prepared: PreparedRequest | null, error: any, startTime: number): ExecutionResult;
+    /**
+     * The format used for error response bodies.
+     *
+     * Override in a subclass (or set via constructor option) to switch formats:
+     * - `'text'`  — plain text (default)
+     * - `'html'`  — HTML for webview display
+     * - `'both'`  — HTML body + plain `error` field
+     */
+    protected get errorBodyFormat(): 'text' | 'html' | 'both';
+    /**
+     * Build a styled HTML string from an error message and optional stack trace.
+     * Useful for rendering errors in a webview Response tab.
+     *
+     * Static so callers can use it independently of an executor instance.
+     */
+    static formatErrorAsHtml(message: string, stack?: string): string;
+}

package/dist/{services → execution}/request-executor.d.ts

@@ -4,10 +4,11 @@
  * Single Responsibility: Orchestrate the complete request execution flow
  * Facade Pattern: Provides simplified interface to complex subsystem
  */
-import { IHttpClient, IRequestPreprocessor } from '../interfaces';
-import { HttpRequest, HttpResponse, RequestOverrides, ScriptResult, UnifiedCollection, UnifiedRequest } from '../interfaces/types';
-import { IForgeEnv } from './forge-env';
-import { ScriptPipeline } from './script-pipeline';
+import { IHttpClient } from '../types/platform';
+import { IScriptExecutor } from '../script/interfaces';
+import { IRequestPreprocessor } from '../http/request-preprocessor';
+import { HttpRequest, HttpResponse, RequestOverrides, ScriptResult, UnifiedCollection, UnifiedRequest } from '../types/types';
+import { IForgeEnv } from '../environment/forge-env';
 /**
  * Options for request execution
  */
@@ -24,6 +25,10 @@ export interface ExecuteOptions {
     additionalVariables?: Record<string, string>;
     /** Timeout override */
     timeout?: number;
+    /** Callback when scripts modify session variables */
+    onSessionChange?: (action: 'set' | 'unset' | 'clear', key?: string, value?: string) => void;
+    /** Callback when scripts modify environment variables */
+    onEnvironmentChange?: (action: 'set' | 'unset' | 'clear', key?: string, value?: string) => void;
 }
 /**
  * Complete execution result
@@ -51,15 +56,17 @@ export interface ExecuteResult {
 export declare class RequestExecutor {
     private readonly httpClient;
     private readonly forgeEnv;
-    private readonly scriptPipeline;
+    private readonly cookieJar?;
     private readonly preprocessor?;
-    private moduleLoader?;
-    constructor(httpClient: IHttpClient, forgeEnv: IForgeEnv, scriptPipeline: ScriptPipeline, preprocessor?: IRequestPreprocessor | undefined, options?: {
+    private scriptExecutor;
+    constructor(httpClient: IHttpClient, forgeEnv: IForgeEnv, cookieJar?: any | undefined, // ICookieJar - optional for cookie support in scripts
+    preprocessor?: IRequestPreprocessor | undefined, options?: {
         forgeRoot?: string;
+        scriptExecutor?: IScriptExecutor;
     });
     /**
      * Execute a request with full pipeline
-     * Uses ScriptSession for shared VM context between pre-request and post-response scripts
+     * Uses RequestScriptSession for shared VM context between pre-request and post-response scripts
      */
     execute(request: UnifiedRequest, collection: UnifiedCollection, options?: ExecuteOptions): Promise<ExecuteResult>;
     /**
@@ -79,8 +86,13 @@ export declare class RequestExecutor {
      */
     private interpolateRequest;
     /**
-     * Create script context
+     * Build script chain for a request
+     * Returns scripts in execution order: collection → folders → request
      */
-    private createScriptContext;
+    private buildScriptChain;
+    /**
+     * Find the folder path from collection root to a request
+     * Returns array of folders in order from root to parent
+     */
+    private findFolderPath;
 }
-//# sourceMappingURL=request-executor.d.ts.map

package/dist/execution/request-preparer-interfaces.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Request Preparer Interface
+ *
+ * Defines the contract for preparing HTTP requests before execution.
+ * Handles variable resolution, header merging, auth injection, body encoding.
+ *
+ * Used by both Request Tester (manual) and Collection Runner (batch).
+ */
+import { ResolvedEnvironment } from '../environment/interfaces';
+import { ExecutionRequest, PreparedRequest } from '../types/types';
+/**
+ * Request Preparer Service Interface
+ *
+ * Extracted from extension's request-execution-handler.ts prepareRequest method.
+ * Shares request preparation logic between Request Tester and Collection Runner.
+ */
+export interface IRequestPreparer {
+    /**
+     * Prepare a request for execution.
+     *
+     * Handles:
+     * - Variable resolution in params, query, headers, body, URL
+     * - Header merging (environment + request headers)
+     * - Authentication (Bearer, Basic, API Key, OAuth2)
+     * - Body encoding based on bodyType
+     * - Content-Type header auto-setting
+     * - URL building with path params, query params
+     *
+     * @param input - Request input data (ExecutionRequest format)
+     * @param environment - Environment name for variable resolution
+     * @param resolvedEnv - Resolved environment configuration
+     * @param extraVariables - Optional extra variables (for data files, script variables)
+     * @returns Prepared request ready for HTTP execution
+     */
+    prepareRequest(input: ExecutionRequest, environment: string, resolvedEnv: ResolvedEnvironment, extraVariables?: Record<string, string>): Promise<PreparedRequest>;
+}

package/dist/execution/request-preparer.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Request Preparer
+ *
+ * Prepares HTTP requests for execution by resolving variables,
+ * merging headers, applying authentication, and encoding body.
+ *
+ * Extracted from extension's request-preparer.ts.
+ * Platform-independent — uses IApplicationInfo instead of vscode.extensions.
+ *
+ * Used by both Request Tester (manual) and Collection Runner (batch).
+ */
+import { IRequestPreprocessor } from '../http/request-preprocessor';
+import { ExecutionRequest, PreparedRequest } from '../types/types';
+import { IEnvironmentConfigService, ResolvedEnvironment } from '../environment/interfaces';
+import { IHttpRequestService } from '../http/interfaces';
+import { IOAuth2TokenManager } from '../auth/interfaces';
+import { IApplicationInfo } from '../types/platform';
+import { IRequestPreparer } from './request-preparer-interfaces';
+/**
+ * RequestPreparer implementation
+ *
+ * Logic extracted from extension's request-execution-handler.ts prepareRequest method.
+ * Shared by Request Tester (manual requests) and Collection Runner (batch requests).
+ */
+export declare class RequestPreparer implements IRequestPreparer {
+    private readonly envConfigService;
+    private readonly httpService;
+    private readonly preprocessor;
+    private readonly tokenManager?;
+    private readonly appInfo?;
+    constructor(envConfigService: IEnvironmentConfigService, httpService: IHttpRequestService, preprocessor: IRequestPreprocessor, tokenManager?: IOAuth2TokenManager | undefined, appInfo?: IApplicationInfo | undefined);
+    prepareRequest(input: ExecutionRequest, environment: string, resolvedEnv: ResolvedEnvironment, extraVariables?: Record<string, string>): Promise<PreparedRequest>;
+    private applyOAuth2;
+    private applyApiKey;
+}