@http-forge/core 0.2.0 → 0.2.1

package/README.md

@@ -11,11 +11,14 @@
 
 **Core Features:**
 - 🚀 **Postman Collections** - Load and execute `.postman_collection.json` and `.forge.json` files
-- 📝 **JavaScript Scripting** - Pre-request and post-response scripts with `pm.*` API (events, variables, assertions)
+- 📝 **JavaScript Scripting** - Pre-request and post-response scripts with full `pm.*` API (variables, assertions, execution flow, visualizer)
 - 🔄 **Dynamic Variables** - Built-in generators: `{{$randomInt}}`, `{{$timestamp}}`, `{{$uuid}}`, `{{$guid}}`, etc.
-- 🌍 **Environments** - Full variable scoping (globals, collection, environment, session, flow-level)
-- 🍪 **Cookie Persistence** - Automatic cookie storage and reuse across request sequences
-- 📊 **Test Assertions** - BDD-style testing with `pm.test()` and `expect()` chains
+- 🌍 **Environments** - Full variable scoping (globals, collection, environment, session, iterationData)
+- 🍪 **Cookie Persistence** - Automatic cookie storage and reuse, `pm.cookies.jar()` and `.toObject()`
+- 📊 **Test Assertions** - BDD-style testing with `pm.test()` (sync/async) and full Chai `expect()` chains
+- 🔐 **CryptoJS** - Full crypto library: hash, HMAC, AES/DES/TripleDES, PBKDF2, encoding helpers
+- 🎯 **Execution Flow** - `pm.setNextRequest()`, `pm.execution.skipRequest()` for suite runner flow control
+- 📈 **Visualizer** - `pm.visualizer.set(template, data)` for custom Handlebars-based HTML output
 - 🔌 **Extensible** - Custom interceptors, HTTP clients, and module loaders
 
 **Ideal for:**
@@ -634,6 +637,24 @@ MIT © Henry Huang
 
 ## 📝 Changelog
 
+### 0.2.0 (Postman API Parity)
+
+- ✅ **Async `pm.test()` support** - Tests with async callbacks are properly awaited
+- ✅ **Expect chain assertions** - `.a(type)`, `.an(type)`, `.deep.equal()`, `.lengthOf()`, `.exist`, `.members()`, `.keys()`, `.string()`
+- ✅ **`pm.iterationData`** scope - Data-driven testing with iteration variables
+- ✅ **Response status getters** - `response.to.be.ok`, `.error`, `.clientError`, `.serverError` work as getters and functions
+- ✅ **Response headers HeaderList** - `.get()`, `.has()`, `.toObject()`, `.each()` on `pm.response.headers`
+- ✅ **`pm.cookies.toObject()`** - Flat `{name: value}` cookie map
+- ✅ **`replaceIn()` on all scopes** - Available on `pm.variables`, `pm.environment`, `pm.collectionVariables`, `pm.globals`
+- ✅ **Sandbox globals** - `xml2Json()`, `jsonStringify()`, `jsonParse()` available in scripts
+- ✅ **Request headers API** - `.toObject()`, `.each()` on `pm.request.headers`
+- ✅ **`pm.execution.setNextRequest()`** - Runner flow control (jump to named request or stop with `null`)
+- ✅ **`pm.execution.skipRequest()`** - Skip HTTP call from pre-request scripts
+- ✅ **`pm.setNextRequest()`** - Top-level alias for flow control
+- ✅ **`pm.visualizer.set(template, data)`** - Custom HTML visualization with Handlebars templates
+- ✅ **`pm.request.url` as Url object** - Postman SDK-compatible Url with `getHost()`, `getPath()`, `getQueryString()`, `protocol`, `host`, `port`, `path`, `query`, `hash`
+- ✅ **Full CryptoJS** - AES/DES/TripleDES encrypt/decrypt, PBKDF2, all hash algorithms (SHA1/256/384/512/SHA3/MD5/RIPEMD160), HMAC, encoding helpers (Hex/Base64/Utf8/Latin1/Utf16)
+
 ### 0.1.0 (Initial Release)
 
 - ✅ **Core request execution** with Postman collection support

package/dist/auth/oauth2-token-manager.d.ts

@@ -15,9 +15,9 @@
  */
 import { IEnvironmentConfigService } from '../environment/interfaces';
 import { IHttpRequestService } from '../http/interfaces';
-import { IOAuth2TokenManager, TokenCacheKey, TokenInfo } from './interfaces';
 import { IExternalBrowserService, ISecretStore } from '../types/platform';
 import { OAuth2Config } from '../types/types';
+import { IOAuth2TokenManager, TokenCacheKey, TokenInfo } from './interfaces';
 export declare class OAuth2TokenManager implements IOAuth2TokenManager {
     private readonly secretStore;
     private readonly browserService;

package/dist/collection/collection-loader-factory.d.ts

@@ -3,8 +3,8 @@
  *
  * Factory Pattern: Creates appropriate loader based on configuration
  */
-import { ICollectionStore } from './collection-store';
 import { IConfigService } from '../config';
+import { ICollectionStore } from './collection-store';
 /**
  * Factory for creating collection loaders
  */

package/dist/collection/collection-service.d.ts

@@ -8,9 +8,9 @@
  * - ConfigService for configuration
  * - CollectionLoader for storage abstraction (supports folder and json formats)
  */
-import { Collection, CollectionItem, CollectionRequestItem, CreateRequestOptions, ICollectionService } from './collection-service-interfaces';
-import { IFileWatcherFactory } from '../types/platform';
 import { IConfigService } from '../config';
+import { IFileWatcherFactory } from '../types/platform';
+import { Collection, CollectionItem, CollectionRequestItem, CreateRequestOptions, ICollectionService } from './collection-service-interfaces';
 /**
  * Service for managing HTTP Forge collections
  */

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

@@ -6,8 +6,8 @@
  * - JsonCollectionLoader: Loads from single JSON files
  * - FolderCollectionStore: Loads from directory structure
  */
-import type { Collection, CollectionItem, RequestScripts } from './collection-service-interfaces';
 import type { CollectionRequest } from '../types/types';
+import type { Collection, CollectionItem, RequestScripts } from './collection-service-interfaces';
 /**
  * Rich interface for loading, saving, and managing collections
  */

package/dist/collection/folder-collection-loader.d.ts

@@ -1,256 +1,45 @@
 /**
  * Folder Collection Loader
  *
- * Loads collections from directory structure (folder format)
- * Each collection is a folder containing:
- * - collection.json (metadata)
- * - scripts/ (pre-request.js, post-response.js)
- * - {folder-slug}/ (subfolders with folder.json)
- * - {request-slug}/ (request folders with request.json)
+ * Thin adapter around FolderCollectionStore that converts between the
+ * `Collection` / `CollectionItem` types (array-based headers/query with
+ * `enabled` flag) and the simpler `UnifiedCollection` / `UnifiedRequest`
+ * types (Record-based headers/query) used by ForgeContainer.
  *
- * This is a port of the VS Code extension's FolderCollectionLoader
+ * All disk I/O is delegated to FolderCollectionStore — this class only
+ * performs type conversion on the way in and out.
  */
-import type { CollectionScripts, RequestBody, UnifiedCollection, UnifiedFolder, UnifiedRequest } from '../types/types';
+import type { CollectionScripts, UnifiedCollection, UnifiedFolder, UnifiedRequest } from '../types/types';
+import type { CollectionMetadata } from './collection-store';
 import type { ICollectionLoader } from './interfaces';
-/**
- * Collection metadata structure
- */
-interface CollectionMetadata {
-    id: string;
-    name: string;
-    description?: string;
-    version?: string;
-    variables?: Record<string, string>;
-    auth?: any;
-    order?: string[];
-}
-/**
- * Scripts structure
- */
-interface Scripts {
-    preRequest?: string;
-    postResponse?: string;
-}
-/**
- * Collection item (folder or request)
- */
-type CollectionItem = UnifiedFolder | UnifiedRequest;
+export { generateSlug } from './folder-io';
+type UnifiedItem = UnifiedFolder | UnifiedRequest;
 /**
  * Folder Collection Loader
  *
- * Loads collections from folder structure:
- * collections/
- *   {collection-slug}/
- *     collection.json
- *     scripts/
- *       pre-request.js
- *       post-response.js
- *     {folder-slug}/
- *       folder.json
- *       scripts/
- *       {request-slug}/
- *         request.json
- *         scripts/
- *     {request-slug}/
- *       request.json
- *       scripts/
+ * Implements `ICollectionLoader` and exposes CRUD using `UnifiedCollection` /
+ * `UnifiedRequest` types. All disk I/O is handled by the underlying
+ * `FolderCollectionStore`; this class converts types on the boundary.
  */
 export declare class FolderCollectionLoader implements ICollectionLoader {
-    protected collectionsDir: string;
-    protected cache: Map<string, UnifiedCollection>;
-    protected slugToIdMap: Map<string, string>;
-    protected idToSlugMap: Map<string, string>;
+    /** The underlying canonical store that handles all disk I/O */
+    private readonly store;
     constructor(collectionsDir: string);
-    /**
-     * Ensure collections directory exists
-     */
-    protected ensureDirectory(): void;
-    /**
-     * Load all collections from disk
-     */
     loadAll(): UnifiedCollection[];
-    /**
-     * Get collection slug from ID
-     */
     getSlugById(id: string): string | undefined;
-    /**
-     * Get collection ID from slug
-     */
     getIdBySlug(slug: string): string | undefined;
-    /**
-     * Load a collection from a folder
-     */
-    protected loadCollectionFromFolder(slug: string): UnifiedCollection | undefined;
-    /**
-     * Load items from a directory
-     * @param dirPath - Directory path to load items from
-     * @param parentId - Parent ID for tracking
-     * @param order - Optional order array (slugs) to sort items
-     */
-    protected loadItemsFromDir(dirPath: string, parentId: string, order?: string[]): CollectionItem[];
-    /**
-     * Load a folder from directory
-     */
-    protected loadFolderFromDir(folderPath: string, slug: string): UnifiedFolder | undefined;
-    /**
-     * Load a request from directory
-     */
-    protected loadRequestFromDir(requestPath: string, slug: string): UnifiedRequest | undefined;
-    /**
-     * Convert array of { key, value, enabled } to Record<string, string>
-     * Also handles Record format (pass-through)
-     * Only includes enabled items (or all if enabled is undefined)
-     */
-    protected arrayToRecord(arr?: Array<{
-        key: string;
-        value: string;
-        enabled?: boolean;
-    }> | Record<string, string>): Record<string, string>;
-    /**
-     * Load scripts from a scripts directory
-     */
-    protected loadScriptsFromDir(scriptsPath: string): Scripts | undefined;
-    /**
-     * Load body from external file if present
-     * Supports: body.json, body.xml, body.txt, body.html, body.js, body.graphql
-     */
-    protected loadBodyFromDir(requestPath: string): RequestBody | undefined;
-    /**
-     * Load a JSON schema file if it exists.
-     * Returns the parsed object or undefined.
-     */
-    protected loadSchemaFile(filePath: string): any | undefined;
-    /**
-     * Load a single collection by ID.
-     * Checks the in-memory cache first, then falls back to slug-map → loadAll().
-     */
     load(id: string): UnifiedCollection | undefined;
-    /**
-     * Create a new empty collection and persist it to disk.
-     */
     create(name: string, id?: string): Promise<UnifiedCollection>;
-    /**
-     * Save (create or update) an entire collection to disk.
-     */
     save(collection: UnifiedCollection): Promise<void>;
-    /**
-     * Delete a collection by ID (removes directory from disk).
-     */
     delete(id: string): Promise<boolean>;
-    /**
-     * Check if a collection exists on disk.
-     */
     exists(id: string): boolean;
-    /**
-     * Get the filesystem path for a collection.
-     */
     getCollectionPath(id: string): string;
-    /**
-     * Update collection-level metadata (name, description, variables, etc.)
-     * without rewriting every item.
-     */
     updateCollectionMetadata(collectionId: string, updates: Partial<CollectionMetadata>): Promise<void>;
-    /**
-     * Save (create or update) a single item within a collection.
-     * @param collectionId - The owning collection
-     * @param item - Folder or request to save
-     * @param parentId - Optional parent folder (omit for root-level)
-     */
-    saveItem(collectionId: string, item: CollectionItem, parentId?: string): Promise<void>;
-    /**
-     * Update a single item's metadata in-place.
-     */
-    updateItem(collectionId: string, itemId: string, updates: Partial<CollectionItem>): Promise<boolean>;
-    /**
-     * Delete a single item (and its directory) from a collection.
-     */
+    saveItem(collectionId: string, item: UnifiedItem, parentId?: string): Promise<void>;
+    updateItem(collectionId: string, itemId: string, updates: Partial<UnifiedItem>): Promise<boolean>;
     deleteItem(collectionId: string, itemId: string): Promise<boolean>;
-    /**
-     * Move an item to a different parent within the same collection.
-     * @param newParentId - Target folder ID, or `undefined` for collection root
-     */
     moveItem(collectionId: string, itemId: string, newParentId?: string): Promise<boolean>;
-    /**
-     * Reorder items within a parent (folder or collection root).
-     * Writes an `order` array into the parent's metadata file.
-     */
     reorderItems(collectionId: string, parentId: string | undefined, orderedItemIds: string[]): Promise<boolean>;
-    /**
-     * Save scripts for a specific item (collection, folder, or request).
-     */
     saveScripts(collectionId: string, itemId: string, scripts: CollectionScripts): Promise<void>;
-    /**
-     * Load scripts for a specific item by ID.
-     */
     loadScripts(collectionId: string, itemId: string): CollectionScripts | undefined;
-    /**
-     * Persist a list of items to a parent directory.
-     */
-    protected saveItemsToDir(parentPath: string, items: CollectionItem[]): Promise<void>;
-    /**
-     * Persist a folder's metadata, scripts, and nested items.
-     */
-    protected saveFolderToDir(folderPath: string, folder: UnifiedFolder): Promise<void>;
-    /**
-     * Persist a request's metadata, body files, schema files, and scripts.
-     */
-    protected saveRequestToDir(requestPath: string, request: UnifiedRequest): Promise<void>;
-    /**
-     * Write scripts to a scripts/ directory.
-     */
-    protected saveScriptsToDir(scriptsPath: string, scripts: CollectionScripts): Promise<void>;
-    /**
-     * Separate body content into metadata-inline vs. external-file parts.
-     */
-    protected prepareBodyForSave(body: RequestBody | undefined): {
-        bodyForMetadata: any;
-        externalBodyFile?: {
-            filename: string;
-            content: string;
-        };
-    };
-    /**
-     * Remove stale body files that don't match the current format.
-     */
-    protected cleanupOldBodyFiles(requestPath: string, currentBodyFile?: string): Promise<void>;
-    /**
-     * Save OpenAPI schema files (response.schema.json, body.schema.json).
-     */
-    protected saveSchemaFiles(requestPath: string, request: UnifiedRequest): Promise<void>;
-    /**
-     * Convert Record<string, string> to the array format used in metadata files.
-     */
-    protected recordToArray(record?: Record<string, string>): Array<{
-        key: string;
-        value: string;
-        enabled: boolean;
-    }> | undefined;
-    /**
-     * Resolve a filesystem path for an item within a collection.
-     */
-    protected findItemPath(collectionId: string, itemId: string): string | undefined;
-    /**
-     * Recursively search for a directory named `targetSlug` under `basePath`.
-     */
-    protected searchForItemPath(basePath: string, targetSlug: string): string | undefined;
-    /**
-     * Find an item by ID in the in-memory tree (recursive).
-     */
-    protected findItemById(items: CollectionItem[], id: string): CollectionItem | undefined;
-    /**
-     * Remove an item from the in-memory tree by ID (mutates the array).
-     */
-    protected deleteItemFromTree(items: CollectionItem[], id: string): boolean;
-    /**
-     * Re-sort items to match an ordered list of IDs.
-     * Items not in `orderedIds` are appended at the end.
-     */
-    protected sortItemsByOrder(items: CollectionItem[], orderedIds: string[]): CollectionItem[];
 }
-/**
- * Generate a slug from a name
- * Handles HTTP method prefixes, version indicators (T7, 1.5), path parameters,
- * and deduplication with counter suffixes.
- */
-export declare function generateSlug(name: string, existingSlugs?: string[]): string;
-export {};

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

@@ -37,6 +37,14 @@ export declare class FolderCollectionStore implements ICollectionStore {
     private slugToIdMap;
     private idToSlugMap;
     constructor(collectionsDir: string);
+    /**
+     * Get collection/item slug from ID
+     */
+    getSlugById(id: string): string | undefined;
+    /**
+     * Get collection/item ID from slug
+     */
+    getIdBySlug(slug: string): string | undefined;
     /**
      * Ensure collections directory exists
      */
@@ -162,7 +170,6 @@ export declare class FolderCollectionStore implements ICollectionStore {
      */
     private sortItemsByOrder;
     private findItemPath;
-    private searchForItemPath;
     private findItemById;
     private deleteItemFromTree;
 }

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

@@ -0,0 +1,113 @@
+/**
+ * Folder Format I/O Primitives
+ *
+ * Shared file I/O operations for the folder-based collection storage format.
+ * Used by both FolderCollectionLoader (read-only, UnifiedCollection types)
+ * and FolderCollectionStore (full CRUD, Collection types).
+ *
+ * Eliminates ~200 lines of duplicated code between the two implementations.
+ */
+import type { RequestBody } from '../types/types';
+/** Script file names within a scripts/ directory */
+export declare const SCRIPT_FILES: {
+    preRequest: string;
+    postResponse: string;
+};
+/** Metadata file names that identify item types */
+export declare const METADATA_FILES: {
+    collection: string;
+    folder: string;
+    request: string;
+};
+/**
+ * Body file extensions mapped to body type/format.
+ * Files stored externally get syntax highlighting benefits.
+ * Other types (form-data, urlencoded, binary, none) stay in request.json.
+ */
+export declare const BODY_FILE_MAP: Record<string, {
+    type: 'raw' | 'graphql';
+    format?: 'json' | 'text' | 'xml' | 'html' | 'javascript';
+}>;
+/** Schema files stored alongside request.json for OpenAPI round-trip support */
+export declare const SCHEMA_FILES: {
+    responseSchema: string;
+    bodySchema: string;
+};
+/** Scripts directory name */
+export declare const SCRIPTS_DIR = "scripts";
+/**
+ * Scripts structure (shared shape between CollectionScripts and RequestScripts)
+ */
+export interface ScriptsData {
+    preRequest?: string;
+    postResponse?: string;
+}
+/**
+ * Read scripts from a scripts/ directory.
+ * Returns undefined if the directory doesn't exist or has no scripts.
+ */
+export declare function readScriptsFromDir(scriptsPath: string): ScriptsData | undefined;
+/**
+ * Write scripts to a scripts/ directory.
+ */
+export declare function writeScriptsToDir(scriptsPath: string, scripts: ScriptsData): Promise<void>;
+/**
+ * Load body from external file if present.
+ * Supports: body.json, body.xml, body.txt, body.html, body.js, body.graphql
+ */
+export declare function readBodyFromDir(requestPath: string): RequestBody | undefined;
+/**
+ * Separate body content into metadata-inline vs. external-file parts.
+ */
+export declare function prepareBodyForSave(body: any): {
+    bodyForMetadata: any;
+    externalBodyFile?: {
+        filename: string;
+        content: string;
+    };
+};
+/**
+ * Remove stale body files that don't match the current format.
+ */
+export declare function cleanupOldBodyFiles(requestPath: string, currentBodyFile?: string): Promise<void>;
+/**
+ * Load a JSON schema file if it exists.
+ * Returns the parsed object or undefined.
+ */
+export declare function readSchemaFile(filePath: string): any | undefined;
+/**
+ * Save OpenAPI schema files (response.schema.json, body.schema.json).
+ */
+export declare function writeSchemaFiles(requestPath: string, responseSchema?: any, bodySchema?: any): Promise<void>;
+/** Minimal interface for tree traversal — both UnifiedFolder/UnifiedRequest and CollectionItem satisfy this */
+interface TreeNode {
+    id: string;
+    type: string;
+    items?: TreeNode[];
+}
+/**
+ * Find an item by ID in a tree (recursive).
+ */
+export declare function findItemById<T extends TreeNode>(items: T[], id: string): T | undefined;
+/**
+ * Remove an item from a tree by ID (mutates the array).
+ */
+export declare function deleteItemFromTree<T extends TreeNode>(items: T[], id: string): boolean;
+/**
+ * Re-sort items to match an ordered list of IDs.
+ * Items not in orderedIds are appended at the end.
+ */
+export declare function sortItemsByOrder<T extends {
+    id: string;
+}>(items: T[], orderedIds: string[]): T[];
+/**
+ * Recursively search for a directory named targetSlug under basePath.
+ */
+export declare function searchForItemPath(basePath: string, targetSlug: string): string | undefined;
+/**
+ * Generate a slug from a name.
+ * Handles HTTP method prefixes, version indicators (T7, 1.5), path parameters,
+ * and deduplication with counter suffixes.
+ */
+export declare function generateSlug(name: string, existingSlugs?: string[]): string;
+export {};

package/dist/container.d.ts

@@ -4,20 +4,20 @@
  * Single Responsibility: Wire up all components with proper dependencies
  * Factory Pattern: Creates configured instances of services
  */
+import { ICollectionLoader } from './collection/interfaces';
+import { ParserRegistry } from './collection/parser-registry';
 import { ICookieService } from './cookie/interfaces';
-import { IDataFileParser } from './platform/data-file-parser';
+import { EnvironmentResolver, EnvironmentStoreConfig } from './environment/environment-resolver';
+import { ForgeEnv } from './environment/forge-env';
+import { IVariableInterpolator } from './environment/interfaces';
+import { RequestExecutor } from './execution/request-executor';
+import { IRequestHistory } from './history/history-interfaces';
 import { IErrorInterceptor, IInterceptorChain, IRequestInterceptor, IResponseInterceptor } from './http/interceptor-chain';
 import { IRequestPreprocessor } from './http/request-preprocessor';
-import { IFileSystem, IHttpClient } from './types/platform';
-import { ICollectionLoader } from './collection/interfaces';
-import { IRequestHistory } from './history/history-interfaces';
+import { IDataFileParser } from './platform/data-file-parser';
 import { IScriptExecutor } from './script/interfaces';
-import { IVariableInterpolator } from './environment/interfaces';
+import { IFileSystem, IHttpClient } from './types/platform';
 import { HttpRequest, HttpResponse, RequestSettings, UnifiedCollection, UnifiedRequest } from './types/types';
-import { EnvironmentResolver, EnvironmentStoreConfig } from './environment/environment-resolver';
-import { ForgeEnv } from './environment/forge-env';
-import { ParserRegistry } from './collection/parser-registry';
-import { RequestExecutor } from './execution/request-executor';
 /**
  * Container configuration options
  */
@@ -135,18 +135,17 @@ export declare class ForgeContainer {
     /**
      * Create a container by auto-loading environments from forgeRoot
      *
-     * Reads `{forgeRoot}/environments/environments.json` and creates
-     * a container with the environment configuration pre-loaded.
+     * Reads the multi-file environment folder format under
+     * `{forgeRoot}/environments/` (same format used by the VS Code extension).
+     * Falls back to the legacy single-file `environments.json` when the
+     * multi-file format is not detected.
      *
      * @param forgeRoot - Path to http-forge folder (default: './http-forge')
      * @param options - Additional container options
      *
      * @example
      * ```typescript
-     * // Auto-load environments from ./http-forge/environments/environments.json
      * const forge = ForgeContainer.fromForgeRoot('./http-forge');
-     *
-     * // Switch environment
      * forge.forgeEnv.setActiveEnvironment('sit');
      * ```
      */

package/dist/cookie/cookie-service.d.ts

@@ -5,8 +5,8 @@
  * Platform-agnostic — uses IKeyValueStore for persistence
  * instead of VS Code globalState.
  */
-import { Cookie, ICookieParser, ICookieReader } from './interfaces';
 import { IKeyValueStore } from '../types/platform';
+import { Cookie, ICookieParser, ICookieReader } from './interfaces';
 /**
  * Full cookie service interface (async write operations for platform persistence)
  */

package/dist/cookie/in-memory-cookie-jar.d.ts

@@ -8,8 +8,8 @@
  * For persistent cookie handling (across requests in a session), use
  * PersistentCookieJar which wraps an ICookieService backend.
  */
-import type { Cookie } from './interfaces';
 import type { ICookieJar } from '../script/interfaces';
+import type { Cookie } from './interfaces';
 export declare class InMemoryCookieJar implements ICookieJar {
     private cookies;
     /**

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

@@ -9,8 +9,8 @@
  *
  * Extracted from extension's request-execution/PersistentCookieJar.ts.
  */
-import { Cookie, IAsyncCookieService, ICookieService } from './interfaces';
 import { ICookieJar } from '../script/interfaces';
+import { Cookie, IAsyncCookieService, ICookieService } from './interfaces';
 export declare class PersistentCookieJar implements ICookieJar {
     private cookieService;
     /** Local cache that reflects script modifications */

package/dist/di/core-bootstrap.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Core Service Bootstrap
+ *
+ * Registers all platform-agnostic services in the ServiceContainer.
+ * The host environment (VS Code, CLI, etc.) only needs to provide
+ * PlatformAdapters — the actual service wiring lives here.
+ *
+ * This is the single source of truth for service dependencies.
+ */
+import type { PlatformAdapters } from './platform-adapters';
+import type { ServiceContainer } from './service-container';
+/**
+ * Register all platform-agnostic core services in the container.
+ *
+ * @param container - The service container to register into
+ * @param adapters - Platform-specific adapters provided by the host
+ *
+ * @example
+ * ```typescript
+ * const container = ServiceContainer.instance;
+ * container.clear();
+ * registerCoreServices(container, adapters);
+ * ```
+ */
+export declare function registerCoreServices(container: ServiceContainer, adapters: PlatformAdapters): void;

package/dist/di/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Dependency Injection
+ *
+ * Provides a generic, platform-agnostic DI container and service bootstrap.
+ * Host environments (VS Code, CLI, etc.) only need to supply PlatformAdapters.
+ */
+export { registerCoreServices } from './core-bootstrap';
+export type { PlatformAdapters } from './platform-adapters';
+export { getServiceContainer, ServiceContainer } from './service-container';
+export { ServiceIdentifiers } from './service-identifiers';
+export type { ServiceIdentifier } from './service-identifiers';