@http-forge/core 0.4.4 → 0.4.5

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/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/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

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/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.5",
   "description": "Headless HTTP testing engine with Postman collection support, dynamic variables, and script-based automation.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",