@http-forge/core 0.4.4 → 0.4.6

package/dist/infrastructure/collection/folder-collection-store.d.ts

@@ -183,6 +183,13 @@ export declare class FolderCollectionStore implements ICollectionStore {
      */
     private sortItemsByOrder;
     private findItemPath;
+    /**
+     * Build the on-disk slug path (root → item) for the given item id by walking the
+     * in-memory collection tree. Each segment is resolved via idToSlugMap so it matches
+     * the folder names produced during save. Returns undefined if the item is not found
+     * or any ancestor lacks a known slug.
+     */
+    private buildSlugPath;
     private findItemById;
     private deleteItemFromTree;
 }

package/dist/infrastructure/collection/folder-io.d.ts

@@ -105,6 +105,15 @@ export declare function sortItemsByOrder<T extends {
  * Recursively search for a directory named targetSlug under basePath.
  */
 export declare function searchForItemPath(basePath: string, targetSlug: string): string | undefined;
+/**
+ * Recursively search for the directory whose metadata id equals targetId.
+ *
+ * Ids are globally unique, whereas slugs are de-duplicated only among siblings — so two
+ * items with the same name in different folders share a leaf slug. Resolving by id (reading
+ * each candidate's metadata) guarantees that only the directory belonging to that exact id
+ * is matched, regardless of slug collisions.
+ */
+export declare function searchForItemPathById(basePath: string, targetId: string): string | undefined;
 /**
  * Generate a slug from a name.
  * Handles HTTP method prefixes, version indicators (T7, 1.5), path parameters,

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

@@ -65,6 +65,7 @@ export declare class ConfigService implements IConfigService {
     getResultsPath(): string;
     getSuitesPath(): string;
     getModulePaths(): string[];
+    getScriptScope(): 'shared' | 'isolated';
     getWorkspacePath(): string;
     reload(): void;
     configExists(): boolean;

package/dist/infrastructure/config/config.interface.d.ts

@@ -35,6 +35,15 @@ export interface RequestConfig {
 export interface ScriptsConfig {
     /** Paths to search for importable modules (relative to workspace) */
     modulePaths: string[];
+    /**
+     * Script scope mode.
+     * - 'shared'   (default): all script levels run in one shared scope; var/function
+     *   declarations leak across levels and across pre-request/post-response phases.
+     *   Lowest overhead; preserves existing behavior.
+     * - 'isolated': each script level runs in its own scope (Postman-compatible). State
+     *   must pass through pm.variables / pm.environment / pm.globals.
+     */
+    scope?: 'shared' | 'isolated';
 }
 /**
  * Runner configuration
@@ -201,6 +210,8 @@ export interface IConfigService {
     getSuitesPath(): string;
     /** Get resolved module paths for script imports */
     getModulePaths(): string[];
+    /** Get the script scope mode ('shared' default, or 'isolated' for Postman parity) */
+    getScriptScope(): 'shared' | 'isolated';
     /** Get the workspace root path */
     getWorkspacePath(): string;
     /** Reload configuration from disk */

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

@@ -113,7 +113,7 @@ export declare class EnvironmentConfigService implements IEnvironmentConfigServi
     private getEnvLocalConfigPath;
     private loadFolderConfigs;
     /**
-     * Create a VariableResolver pre-loaded with environment + session variables.
+     * Create a VariableResolver pre-loaded with environment variables.
      */
     private createResolver;
     private saveFolderSharedConfig;

package/dist/infrastructure/environment/environment-resolver.d.ts

@@ -77,6 +77,15 @@ export declare class EnvironmentResolver implements IEnvironmentStore {
      * Set a global variable
      */
     setGlobal(key: string, value: string): void;
+    /**
+     * Remove a session global variable. File-defined globals (globalVariables)
+     * are defaults and cannot be deleted here — only session overrides are removed.
+     */
+    unsetGlobal(key: string): void;
+    /**
+     * Clear all session global variables. File-defined globals are left intact.
+     */
+    clearGlobals(): void;
     /**
      * Resolve environment for execution
      */

package/dist/infrastructure/environment/forge-env.d.ts

@@ -30,8 +30,8 @@
  * env.get('token');  // 'abc'
  * ```
  */
-import { EnvironmentResolver } from './environment-resolver';
 import type { IEnvironmentStore, IVariableInterpolator } from '../../types/environment-config';
+import { EnvironmentResolver } from './environment-resolver';
 /**
  * ForgeEnv interface - the public API for environment management
  */
@@ -69,6 +69,22 @@ export interface IForgeEnv {
      * Get list of available environment names
      */
     getEnvironments(): string[];
+    /**
+     * Get all global variables (environment-agnostic variable layer)
+     */
+    getGlobals(): Record<string, string>;
+    /**
+     * Set a global variable value
+     */
+    setGlobal(key: string, value: string): void;
+    /**
+     * Remove a global variable
+     */
+    unsetGlobal(key: string): void;
+    /**
+     * Clear all (session) global variables
+     */
+    clearGlobals(): void;
     /**
      * Resolve {{variable}} placeholders in a string
      */
@@ -127,6 +143,23 @@ export declare class ForgeEnv implements IForgeEnv {
      * Get list of available environment names
      */
     getEnvironments(): string[];
+    /**
+     * Get all global variables. Globals are the lowest-priority, environment-agnostic
+     * variable layer — treated like environment variables with no environment scope.
+     */
+    getGlobals(): Record<string, string>;
+    /**
+     * Set a global variable value.
+     */
+    setGlobal(key: string, value: string): void;
+    /**
+     * Remove a (session) global variable.
+     */
+    unsetGlobal(key: string): void;
+    /**
+     * Clear all (session) global variables.
+     */
+    clearGlobals(): void;
     /**
      * Resolve {{variable}} placeholders
      */

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

@@ -28,13 +28,12 @@ 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
+ * Variable precedence: globals > collection > environment > request > extra
  */
 export declare class VariableResolver {
     private readonly allVariables;

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

@@ -61,6 +61,7 @@ export declare class RequestExecutor {
     preprocessor?: IRequestPreprocessor | undefined, options?: {
         forgeRoot?: string;
         scriptExecutor?: IScriptExecutor;
+        scriptScope?: 'shared' | 'isolated';
     });
     /**
      * Execute a request with full pipeline

package/dist/infrastructure/script/interfaces.d.ts

@@ -61,7 +61,6 @@ export interface CommonScriptContext {
     variables: Record<string, string>;
     collectionVariables?: Record<string, string>;
     globals?: Record<string, string>;
-    sessionVariables?: Record<string, string>;
     environmentVariables?: Record<string, string>;
     environmentName?: string;
     sendRequest?: (options: any) => Promise<any>;
@@ -70,6 +69,7 @@ export interface CommonScriptContext {
     iterationCount?: number;
     iterationData?: Record<string, any>;
     onEnvironmentChange?: (action: 'set' | 'unset' | 'clear', key?: string, value?: string) => void;
+    onGlobalsChange?: (action: 'set' | 'unset' | 'clear', key?: string, value?: string) => void;
 }
 /**
  * Script execution context for pre-request scripts
@@ -95,7 +95,6 @@ export interface PreRequestScriptResult {
     modifiedVariables?: Record<string, string>;
     modifiedCollectionVariables?: Record<string, string>;
     modifiedGlobals?: Record<string, string>;
-    modifiedSessionVariables?: Record<string, string>;
     modifiedEnvironmentVariables?: Record<string, string>;
     consoleOutput?: string[];
     /** Postman-compatible: pm.execution.setNextRequest() value. null = stop runner. */
@@ -110,7 +109,8 @@ export interface PostResponseScriptResult {
     testResults: TestAssertion[];
     consoleOutput?: string[];
     modifiedEnvironmentVariables?: Record<string, string>;
-    modifiedSessionVariables?: Record<string, string>;
+    modifiedGlobals?: Record<string, string>;
+    modifiedCollectionVariables?: Record<string, string>;
     /** Postman-compatible: pm.execution.setNextRequest() value. null = stop runner. */
     nextRequest?: string | null;
     /** Postman-compatible: pm.visualizer.set(template, data) output */

package/dist/infrastructure/script/request-script-session.d.ts

@@ -16,6 +16,8 @@ import { CommonScriptContext, IRequestScriptSession, PostResponseScriptResult, P
 export interface SessionDependencies {
     createVM: (ctx: any, scriptConsole: any) => vm.Context;
     createCommonContext: (context: CommonScriptContext, eventName: 'prerequest' | 'test') => any;
+    /** When true, each script level runs in its own scope (Postman-compatible). */
+    isolateScripts?: boolean;
 }
 /**
  * Request Script Session Implementation

package/dist/infrastructure/script/script-executor.d.ts

@@ -22,8 +22,9 @@ import { IRequestScriptSession, IScriptExecutor, PreRequestScriptContext } from
 export declare class ScriptExecutor implements IScriptExecutor {
     private readonly httpService?;
     private readonly secretRegistry?;
+    private readonly scopeMode;
     private readonly moduleLoader;
-    constructor(httpService?: IHttpRequestService | undefined, modulePaths?: string[], secretRegistry?: SecretResolverRegistry | undefined);
+    constructor(httpService?: IHttpRequestService | undefined, modulePaths?: string[], secretRegistry?: SecretResolverRegistry | undefined, scopeMode?: 'shared' | 'isolated');
     /**
      * Create a request execution session
      * Factory method implementing IScriptExecutor
@@ -54,6 +55,13 @@ export declare class ScriptExecutor implements IScriptExecutor {
      * Create a basic variable scope with get/set/has/unset/clear/toObject
      */
     private createVariableScope;
+    /**
+     * Create the globals scope with change callbacks.
+     * Globals are a special, environment-agnostic variable layer, so they are
+     * persisted live through the same push-callback mechanism as environment
+     * variables (see createEnvironmentScope) rather than a post-hoc diff.
+     */
+    private createGlobalsScope;
     /**
      * Create merged variable scope (Postman-style cascading lookup)
      */

package/dist/infrastructure/script/script-utils.d.ts

@@ -13,10 +13,17 @@ export interface ConsoleMessage {
     args: any[];
 }
 /**
- * Concatenate multiple scripts into one with clear separators
- * Enables variables defined in earlier scripts to be accessible in later scripts
- */
-export declare function concatenateScripts(scripts: string | string[]): string;
+ * Concatenate multiple scripts into one program.
+ *
+ * - shared (default): scripts are joined into one scope, so variables/functions declared
+ *   in an earlier script are visible to later scripts (and, via var/function hoisting onto
+ *   the shared VM global, to the post-response phase).
+ * - isolated: each script unit is wrapped in its own async IIFE, so its var/const/let/function
+ *   declarations cannot collide within a phase or leak across phases (Postman parity). The
+ *   whole batch is wrapped in one outer async IIFE so top-level `await` inside any unit works
+ *   and the program resolves to an awaitable promise.
+ */
+export declare function concatenateScripts(scripts: string | string[], isolate?: boolean): string;
 /**
  * Check if an object has changed from its original value
  * Uses JSON serialization for deep comparison

package/dist/infrastructure/test-suite/result-storage.d.ts

@@ -227,8 +227,6 @@ export interface FullResultDetails {
     modifiedEnvironmentVariables?: Record<string, string>;
     /** Collection variables modified by scripts */
     modifiedCollectionVariables?: Record<string, string>;
-    /** Session variables modified by scripts */
-    modifiedSessionVariables?: Record<string, string>;
     /** pm.execution.setNextRequest() value */
     nextRequest?: string | null;
     /** pm.visualizer.set() payload */

package/dist/types/types.d.ts

@@ -218,7 +218,6 @@ export interface ExecutionVariables {
     variables: Record<string, string>;
     collectionVariables?: Record<string, string>;
     globals?: Record<string, string>;
-    sessionVariables?: Record<string, string>;
     environmentVariables?: Record<string, string>;
 }
 /**
@@ -619,7 +618,6 @@ export interface ExecutionResult {
     modifiedVariables?: Record<string, string>;
     modifiedEnvironmentVariables?: Record<string, string>;
     modifiedCollectionVariables?: Record<string, string>;
-    modifiedSessionVariables?: Record<string, string>;
     error?: string;
     /** Folder path of the request within its collection (slash-separated; empty for root) */
     folderPath?: string;

package/dist/utils/helpers.d.ts

@@ -10,7 +10,8 @@
 export declare function sanitizeName(name: string): string;
 /**
  * Generate a unique identifier.
- * Uses timestamp + random string for uniqueness.
+ * Combines a base-36 timestamp, a per-process monotonic counter, and a random
+ * suffix so ids created in the same millisecond are still distinct.
  * Optional prefix is sanitized and prepended.
  */
 export declare function generateId(prefix?: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@http-forge/core",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "Headless HTTP testing engine with Postman collection support, dynamic variables, and script-based automation.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",