@http-forge/core 0.2.0 → 0.2.2

package/dist/{http → infrastructure/http}/fetch-http-client.d.ts

@@ -4,8 +4,8 @@
  * Single Responsibility: Execute HTTP requests using fetch API
  * Dependency Inversion: Implements IHttpClient interface
  */
-import { IHttpClient } from '../types/platform';
-import { HttpRequest, HttpResponse } from '../types/types';
+import { IHttpClient } from '../../types/platform';
+import { HttpRequest, HttpResponse } from '../../types/types';
 /**
  * HTTP client implementation using Node.js native fetch.
  * Requires Node.js 18+.

package/dist/{http → infrastructure/http}/http-request-service.d.ts

@@ -15,9 +15,9 @@
  * - Open/Closed: Extended through interceptor chain
  * - Dependency Inversion: Depends on IHttpClient, IUrlBuilder, IInterceptorChain, IRequestPreprocessor
  */
+import type { IHttpClient } from '../../types/platform';
+import { HttpRequestOptions, HttpResponse } from '../../types/types';
 import { IInterceptorChain } from './interceptor-chain';
-import { HttpRequestOptions, HttpResponse } from '../types/types';
-import type { IHttpClient } from '../types/platform';
 import { IHttpRequestService } from './interfaces';
 import { IUrlBuilder } from './url-builder';
 export declare class HttpRequestService implements IHttpRequestService {

package/dist/infrastructure/http/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * HTTP Infrastructure Adapters and Implementations
+ */
+export * from './node-http-executor.adapter';

package/dist/{http → infrastructure/http}/interceptor-chain.d.ts

@@ -12,7 +12,7 @@
  * - Post-response processing (modify response after receiving)
  * - Error handling
  */
-import { HttpRequest, HttpResponse } from '../types/types';
+import { HttpRequest, HttpResponse } from '../../types/types';
 /**
  * Context passed to interceptors
  * Same as plugin's InterceptorContext

package/dist/{http → infrastructure/http}/interfaces.d.ts

@@ -7,7 +7,7 @@
  * This is the high-level service interface that consumers use.
  * It delegates to IHttpClient for actual network calls and IUrlBuilder for URL construction.
  */
-import { HttpRequestOptions, HttpResponse } from '../types/types';
+import { HttpRequestOptions, HttpResponse } from '../../types/types';
 /**
  * Full HTTP request service interface.
  * Combines execution + URL building in a single facade.

package/dist/{http → infrastructure/http}/merge-request-settings.d.ts

@@ -4,7 +4,7 @@
  * Merges user-provided request settings with defaults.
  * Extracted from extension's utils/merge-request-settings.ts.
  */
-import { RequestSettings } from '../types/types';
+import { RequestSettings } from '../../types/types';
 /**
  * Merge user-provided RequestSettings with defaults.
  * Idempotent and safe to call from multiple layers.

package/dist/{http → infrastructure/http}/native-http-client.d.ts

@@ -14,8 +14,8 @@
  * - Request cancellation via AbortSignal
  * - Cookie parsing from Set-Cookie headers
  */
-import { IHttpClient } from '../types/platform';
-import { HttpRequest, HttpResponse, RequestSettings } from '../types/types';
+import { IHttpClient } from '../../types/platform';
+import { HttpRequest, HttpResponse, RequestSettings } from '../../types/types';
 /**
  * Default request settings
  * Same as plugin's DEFAULT_REQUEST_SETTINGS from shared/constants.ts

package/dist/infrastructure/http/node-http-executor.adapter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Node HTTP Executor Adapter - Implements IHttpExecutor
+ *
+ * Wraps existing InterceptorChain and CookieService to conform to port interface
+ */
+import { IHttpExecutor, IExecutionPlan } from '../../ports/executors/http-executor.interface';
+import { HttpRequest, HttpResponse } from '../../types/types';
+import type { IInterceptorChain } from './interceptor-chain';
+import type { ICookieService } from '../cookie/interfaces';
+/**
+ * Adapter that implements IHttpExecutor using existing infrastructure
+ */
+export declare class NodeHttpExecutorAdapter implements IHttpExecutor {
+    private interceptorChain;
+    private cookieJar;
+    constructor(interceptorChain: IInterceptorChain, cookieJar: ICookieService);
+    /**
+     * Prepare request for execution
+     */
+    prepare(plan: IExecutionPlan): Promise<HttpRequest>;
+    /**
+     * Execute prepared HTTP request
+     */
+    execute(prepared: HttpRequest): Promise<HttpResponse>;
+}

package/dist/{http → infrastructure/http}/request-preprocessor.d.ts

@@ -6,7 +6,7 @@
  * Single Responsibility: Handles request preparation (header sanitization, body encoding)
  * DO NOT modify the core logic - it has been tested and is reliable.
  */
-import { RequestBody } from '../types/types';
+import { RequestBody } from '../../types/types';
 /**
  * Request Preprocessor Interface
  * Same as plugin's IRequestPreprocessor

package/dist/{import-export → infrastructure/import-export}/import-postman-environment.d.ts

@@ -6,9 +6,9 @@
  *
  * Pure function — no platform dependencies.
  */
-import { IFileSystem } from '../types/platform';
-import { ImportedEnvironment } from '../environment/interfaces';
-export type { ImportedEnvironment } from '../environment/interfaces';
+import { ImportedEnvironment } from '../../types/environment-config';
+import { IFileSystem } from '../../types/platform';
+export type { ImportedEnvironment } from '../../types/environment-config';
 /**
  * Parse Postman environment JSON content.
  * Supports both standard and nested Postman export formats.

package/dist/{import-export → infrastructure/import-export}/rest-client-export.d.ts

@@ -4,9 +4,9 @@
  * Pure functions for exporting collections to REST Client format (.http files).
  * No VS Code dependency — uses only Node.js fs/path and core types.
  */
-import type { Collection, CollectionItem, ICollectionService } from '../collection/interfaces';
-import type { IEnvironmentConfigService } from '../environment/interfaces';
-import type { RequestScripts } from '../types/types';
+import type { Collection, CollectionItem, ICollectionService } from '../../types/collection';
+import type { IEnvironmentConfigService } from '../../types/environment-config';
+import type { RequestScripts } from '../../types/types';
 /**
  * Write an env file given an object of key/value pairs. Existing file is overwritten.
  */

package/dist/infrastructure/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Infrastructure Layer - Implementations and Adapters
+ *
+ * Contains:
+ * - Repository implementations (file-system, in-memory, cloud)
+ * - HTTP executor implementations
+ * - Script executor implementations
+ * - Storage implementations (history, cache)
+ * - Parser implementations
+ * - External adapters (FileSystem, HTTP client, Logger)
+ * - DI configuration
+ *
+ * Constraints:
+ * - Depends on Ports and Domain layers
+ * - NO direct dependencies on Application layer
+ * - Contains all platform-specific code
+ * - All implementations must conform to port interfaces
+ *
+ * Usage:
+ * - Imported during bootstrap phase
+ * - Never imported by domain layer
+ * - Imported by application layer only through ports
+ */
+export * from './adapters';
+export * from './repositories/in-memory';
+export * from './repositories/file-system';
+export * from './http';
+export * from './script';
+export * from './persistence';
+export * from './parsers';
+export * from './di';

package/dist/{openapi → infrastructure/openapi}/example-generator.d.ts

@@ -5,7 +5,7 @@
  * Handles allOf (flatten + merge), oneOf/anyOf (first variant),
  * discriminator injection, enum, formats, readOnly omission.
  */
-import { JSONSchema7 } from '../types/types';
+import { JSONSchema7 } from '../../types/types';
 export declare class ExampleGenerator {
     /**
      * Generate an example value from a JSON Schema.

package/dist/{openapi → infrastructure/openapi}/history-analyzer.d.ts

@@ -5,7 +5,7 @@
  * to build response schemas by inferring from actual response data.
  */
 import { IRequestHistoryService } from '../history/request-history-service-interfaces';
-import { ResponseSchemaDefinition } from '../types/types';
+import { ResponseSchemaDefinition } from '../../types/types';
 import { SchemaInferrer } from './schema-inferrer';
 export declare class HistoryAnalyzer {
     private historyService;

package/dist/{openapi → infrastructure/openapi}/interfaces.d.ts

@@ -4,10 +4,10 @@
  * DI abstractions for OpenAPI-related services.
  * The concrete implementations live in services/openapi/.
  */
+import type { Collection } from '../../types/collection';
+import type { BodySchemaDefinition, JSONSchema7, KeyValueEntry, ResponseSchemaDefinition } from '../../types/types';
 import type { OpenApiExportOptions } from './openapi-exporter';
 import type { OpenApiImportOptions } from './openapi-importer';
-import type { Collection } from '../collection/collection-service-interfaces';
-import type { BodySchemaDefinition, JSONSchema7, KeyValueEntry, ResponseSchemaDefinition } from '../types/types';
 /**
  * Schema inference service interface
  */

package/dist/{openapi → infrastructure/openapi}/openapi-exporter.d.ts

@@ -4,8 +4,8 @@
  * Generates a valid OpenAPI 3.0.3 document from an HTTP Forge collection.
  * Implements all mapping rules per the solution document §4.3.2.
  */
-import { ICollectionService } from '../collection/interfaces';
-import { IEnvironmentConfigService } from '../environment/interfaces';
+import { ICollectionService } from '../../types/collection';
+import { IEnvironmentConfigService } from '../../types/environment-config';
 import { SchemaInferenceService } from './schema-inference-service';
 export interface OpenApiExportOptions {
     format: 'json' | 'yaml';

package/dist/{openapi → infrastructure/openapi}/openapi-importer.d.ts

@@ -4,8 +4,8 @@
  * Parses an OpenAPI 3.0 spec and creates a fully hydrated HTTP Forge collection.
  * Implements all mapping rules per the solution document §4.4.2.
  */
-import { Collection, ICollectionService } from '../collection/interfaces';
-import { IEnvironmentConfigService } from '../environment/interfaces';
+import { Collection, ICollectionService } from '../../types/collection';
+import { IEnvironmentConfigService } from '../../types/environment-config';
 export interface OpenApiImportOptions {
     /** Base environment name to create with server URL */
     environmentName?: string;

package/dist/{openapi → infrastructure/openapi}/schema-inference-service.d.ts

@@ -9,7 +9,7 @@
  * 2. History data — real response bodies provide the most accurate schemas
  * 3. Script hints — field paths and types from post-response scripts
  */
-import { BodySchemaDefinition, KeyValueEntry, ResponseSchemaDefinition } from '../types/types';
+import { BodySchemaDefinition, KeyValueEntry, ResponseSchemaDefinition } from '../../types/types';
 import { HistoryAnalyzer } from './history-analyzer';
 import { SchemaInferrer } from './schema-inferrer';
 import { ScriptAnalyzer } from './script-analyzer';

package/dist/{openapi → infrastructure/openapi}/schema-inferrer.d.ts

@@ -4,7 +4,7 @@
  * Core utility that generates JSON Schema (OAS 3.0 compatible) from sample JSON values.
  * Supports recursive inference, format detection, schema merging, and nullable semantics.
  */
-import { JSONSchema7 } from '../types/types';
+import { JSONSchema7 } from '../../types/types';
 export declare class SchemaInferrer {
     /**
      * Infer a JSON Schema from a sample value.

package/dist/infrastructure/parsers/collection-parser.adapter.d.ts

@@ -0,0 +1,32 @@
+/**
+ * HTTP Forge Collection Parser Adapter - Implements ICollectionParser
+ *
+ * Wraps existing HttpForgeParser to conform to the port interface
+ */
+import { ICollectionParser } from '../../ports/parsers/collection-parser.interface';
+import { UnifiedCollection } from '../../types/types';
+/**
+ * Adapter that implements ICollectionParser for HTTP Forge format
+ */
+export declare class HttpForgeCollectionParserAdapter implements ICollectionParser {
+    private parser;
+    get supportedFormats(): string[];
+    canHandle(content: string, format?: string): boolean;
+    parse(content: string): Promise<UnifiedCollection>;
+}
+/**
+ * Collection Parser Registry - Manages multiple parsers
+ *
+ * Implements ICollectionParser by delegating to registered parsers
+ */
+export declare class CollectionParserRegistry implements ICollectionParser {
+    private parsers;
+    constructor(initialParsers?: ICollectionParser[]);
+    /**
+     * Register a parser
+     */
+    register(parser: ICollectionParser): void;
+    get supportedFormats(): string[];
+    canHandle(content: string, format?: string): boolean;
+    parse(content: string, format?: string): Promise<UnifiedCollection>;
+}

package/dist/{parsers → infrastructure/parsers}/http-forge-parser.d.ts

@@ -4,8 +4,8 @@
  * Single Responsibility: Parse HTTP Forge collection format (.forge.json)
  * Dependency Inversion: Implements ICollectionParser interface
  */
-import { ICollectionParser } from '../collection/interfaces';
-import { UnifiedCollection } from '../types/types';
+import { ICollectionParser } from '../../types/collection';
+import { UnifiedCollection } from '../../types/types';
 /**
  * Parser for HTTP Forge native collection format
  */

package/dist/infrastructure/parsers/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Parser Infrastructure Implementations
+ *
+ * Collection format parsers for different formats
+ */
+export * from './collection-parser.adapter';
+export { HttpForgeParser } from './http-forge-parser';

package/dist/infrastructure/persistence/file-system-history-loader.d.ts

@@ -0,0 +1,31 @@
+/**
+ * File System History Loader Implementation
+ *
+ * Implements IHistoryLoader using file-based storage
+ * Compatible with existing RequestHistoryService
+ */
+import { IHistoryLoader, IHistoryEntry } from '../../ports/storage/history-loader.interface';
+import { HttpResponse } from '../../types/types';
+import { IFileSystem } from '../../ports/external/file-system.interface';
+/**
+ * File system implementation of IHistoryLoader
+ * Stores execution history in timestamped files
+ */
+export declare class FileSystemHistoryLoader implements IHistoryLoader {
+    private fileSystem;
+    private basePath;
+    private readonly historyDir;
+    private readonly manifestFile;
+    private readonly responseExt;
+    constructor(fileSystem: IFileSystem, basePath: string);
+    loadHistory(collectionId: string, requestId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<IHistoryEntry[]>;
+    loadFullResponse(collectionId: string, requestId: string, entryId: string): Promise<HttpResponse | null>;
+    saveEntry(collectionId: string, requestId: string, response: HttpResponse, duration: number): Promise<IHistoryEntry>;
+    /**
+     * Generate unique entry ID
+     */
+    private generateEntryId;
+}

package/dist/infrastructure/persistence/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Persistence Infrastructure Implementations
+ *
+ * Includes history storage, caching, and other persistence concerns
+ */
+export * from './file-system-history-loader';

package/dist/{platform → infrastructure/platform}/node-file-system.d.ts

@@ -4,7 +4,7 @@
  * Single Responsibility: File operations using Node.js fs module
  * Dependency Inversion: Implements IFileSystem interface
  */
-import { IFileSystem } from '../types/platform';
+import { IFileSystem } from '../../types/platform';
 /**
  * Node.js implementation of IFileSystem.
  * Uses Node.js fs/promises for all operations.

package/dist/infrastructure/repositories/file-system/fs-collection-repository.d.ts

@@ -0,0 +1,72 @@
+/**
+ * File System Collection Repository
+ *
+ * Implements ICollectionRepository using the FolderCollectionStore.
+ *
+ * Delegates to FolderCollectionStore for all disk operations,
+ * converting between UnifiedCollection (repository contract) and
+ * Collection (internal format).
+ *
+ * This ensures a single source of truth for folder-based storage
+ * while supporting both the legacy CollectionService and new use-case architecture.
+ */
+import { ICollectionRepository } from '../../../ports/repositories/collection-repository.interface';
+import { UnifiedCollection } from '../../../types/types';
+/**
+ * File system collection repository implementation using FolderCollectionStore
+ */
+export declare class FileSystemCollectionRepository implements ICollectionRepository {
+    private store;
+    constructor(basePath: string);
+    /**
+     * Find collection by ID
+     */
+    findById(id: string): Promise<UnifiedCollection | null>;
+    /**
+     * Find all collections
+     */
+    findAll(): Promise<UnifiedCollection[]>;
+    /**
+     * Save or update collection
+     */
+    save(id: string, collection: UnifiedCollection): Promise<void>;
+    /**
+     * Delete collection
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Check if collection exists
+     */
+    exists(id: string): Promise<boolean>;
+    /**
+     * Convert internal Collection to UnifiedCollection
+     */
+    private toUnifiedCollection;
+    /**
+     * Convert UnifiedCollection to internal Collection
+     */
+    private toCollection;
+    /**
+     * Normalize auth object to remove oauth2 type if present
+     * Converts RequestAuth to CollectionAuth by removing oauth2-specific fields
+     */
+    private normalizeAuth;
+    /**
+     * Recursively convert items from internal format to unified
+     * PRESERVES: enabled flags, metadata on headers/query, all request fields
+     */
+    private itemsToUnified;
+    /**
+     * Recursively convert items from unified format to internal
+     * PRESERVES: enabled flags, metadata, all request fields
+     */
+    private itemsFromUnified;
+    /**
+     * Convert variables Record to unified format
+     */
+    private recordToUnified;
+    /**
+     * Convert variables from unified format to Record
+     */
+    private unifiedToRecord;
+}

package/dist/infrastructure/repositories/file-system/fs-environment-file-loader.adapter.d.ts

@@ -0,0 +1,41 @@
+/**
+ * File System Environment File Loader Adapter
+ *
+ * Loads environment configuration files from disk
+ * Wraps the legacy environment-file-loader functionality
+ */
+import { IFileSystem } from '../../../ports/external/file-system.interface';
+import { ILogger } from '../../../ports/external/logger.interface';
+export interface EnvironmentFileConfig {
+    name: string;
+    variables: Record<string, string>;
+    [key: string]: any;
+}
+export interface EnvironmentLoadResult {
+    environments: Record<string, EnvironmentFileConfig>;
+    globalVariables?: Record<string, string>;
+}
+/**
+ * Adapter: Load environment files from file system
+ */
+export declare class FileSystemEnvironmentFileLoaderAdapter {
+    private fileSystem;
+    private logger;
+    constructor(fileSystem: IFileSystem, logger: ILogger);
+    /**
+     * Load single environment file
+     */
+    loadEnvironmentFile(filePath: string): Promise<EnvironmentFileConfig>;
+    /**
+     * Load all environment files from directory
+     */
+    loadEnvironmentDirectory(dirPath: string): Promise<EnvironmentLoadResult>;
+    /**
+     * Write environment file
+     */
+    saveEnvironmentFile(filePath: string, config: EnvironmentFileConfig): Promise<void>;
+    /**
+     * Delete environment file
+     */
+    deleteEnvironmentFile(filePath: string): Promise<void>;
+}

package/dist/infrastructure/repositories/file-system/fs-environment-repository.d.ts

@@ -0,0 +1,34 @@
+/**
+ * File System Environment Repository Implementation
+ *
+ * Implements IEnvironmentRepository using folder-based storage
+ * Compatible with existing EnvironmentResolver and environment-file-loader
+ */
+import { IEnvironmentRepository } from '../../../ports/repositories/environment-repository.interface';
+import { Environment } from '../../environment/environment-resolver';
+import { IFileSystem } from '../../../ports/external/file-system.interface';
+/**
+ * File system implementation of IEnvironmentRepository
+ * Stores environments in a dedicated directory
+ */
+export declare class FileSystemEnvironmentRepository implements IEnvironmentRepository {
+    private fileSystem;
+    private basePath;
+    private readonly environmentsDir;
+    private readonly environmentExt;
+    private activeEnvironmentId;
+    constructor(fileSystem: IFileSystem, basePath: string);
+    findById(id: string): Promise<Environment | null>;
+    findActive(): Promise<Environment | null>;
+    findAll(): Promise<Environment[]>;
+    save(environment: Environment): Promise<void>;
+    delete(id: string): Promise<void>;
+    /**
+     * Set environment as active
+     */
+    setActive(id: string): void;
+    /**
+     * Build file path for environment
+     */
+    private buildEnvironmentPath;
+}

package/dist/infrastructure/repositories/file-system/fs-request-repository.d.ts

@@ -0,0 +1,31 @@
+/**
+ * File System Request Repository Implementation
+ *
+ * Implements IRequestRepository using folder-based storage
+ * Compatible with existing FolderCollectionStore and folder-io
+ */
+import { IRequestRepository } from '../../../ports/repositories/request-repository.interface';
+import { UnifiedRequest } from '../../../types/types';
+import { IFileSystem } from '../../../ports/external/file-system.interface';
+/**
+ * File system implementation of IRequestRepository
+ * Stores requests as .json files in collection directories
+ */
+export declare class FileSystemRequestRepository implements IRequestRepository {
+    private fileSystem;
+    private collectionsBasePath;
+    private readonly requestsDir;
+    private readonly requestExt;
+    constructor(fileSystem: IFileSystem, collectionsBasePath: string);
+    findById(id: string): Promise<UnifiedRequest | null>;
+    findAll(collectionId: string): Promise<UnifiedRequest[]>;
+    save(request: UnifiedRequest): Promise<void>;
+    delete(id: string): Promise<void>;
+    exists(id: string): Promise<boolean>;
+    /**
+     * Build file path for a request
+     * Assumes request ID contains collection ID in some form
+     * or that we have configuration for this
+     */
+    private buildRequestPath;
+}

package/dist/infrastructure/repositories/file-system/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * File System Repository Implementations
+ */
+export * from './fs-request-repository';
+export * from './fs-environment-repository';
+export * from './fs-collection-repository';
+export * from './fs-environment-file-loader.adapter';

package/dist/infrastructure/repositories/in-memory/in-memory-collection-repository.d.ts

@@ -0,0 +1,18 @@
+/**
+ * In-Memory Collection Repository
+ *
+ * Useful for testing and development
+ */
+import { ICollectionRepository } from '../../../ports/repositories/collection-repository.interface';
+import { UnifiedCollection } from '../../../types/types';
+/**
+ * In-memory collection repository implementation
+ */
+export declare class InMemoryCollectionRepository implements ICollectionRepository {
+    private collections;
+    findById(id: string): Promise<UnifiedCollection | null>;
+    findAll(filter?: any): Promise<UnifiedCollection[]>;
+    save(id: string, collection: UnifiedCollection): Promise<void>;
+    delete(id: string): Promise<void>;
+    exists(id: string): Promise<boolean>;
+}

package/dist/infrastructure/repositories/in-memory/in-memory-environment-repository.d.ts

@@ -0,0 +1,25 @@
+/**
+ * In-Memory Environment Repository Implementation
+ */
+import { Environment } from '../../environment/environment-resolver';
+import { IEnvironmentRepository } from '../../../ports/repositories/environment-repository.interface';
+/**
+ * In-memory implementation of IEnvironmentRepository
+ */
+export declare class InMemoryEnvironmentRepository implements IEnvironmentRepository {
+    private environments;
+    private activeId;
+    findById(id: string): Promise<Environment | null>;
+    findActive(): Promise<Environment | null>;
+    findAll(): Promise<Environment[]>;
+    save(environment: Environment): Promise<void>;
+    delete(id: string): Promise<void>;
+    /**
+     * Set active environment
+     */
+    setActive(id: string): void;
+    /**
+     * Clear all environments
+     */
+    clear(): void;
+}

package/dist/infrastructure/repositories/in-memory/in-memory-request-repository.d.ts

@@ -0,0 +1,25 @@
+/**
+ * In-Memory Request Repository Implementation
+ */
+import { UnifiedRequest } from '../../../types/types';
+import { IRequestRepository } from '../../../ports/repositories/request-repository.interface';
+/**
+ * In-memory implementation of IRequestRepository
+ * Useful for testing and as a fallback
+ */
+export declare class InMemoryRequestRepository implements IRequestRepository {
+    private requests;
+    findById(id: string): Promise<UnifiedRequest | null>;
+    findAll(collectionId: string): Promise<UnifiedRequest[]>;
+    save(request: UnifiedRequest): Promise<void>;
+    delete(id: string): Promise<void>;
+    exists(id: string): Promise<boolean>;
+    /**
+     * Clear all requests (useful for testing)
+     */
+    clear(): void;
+    /**
+     * Pre-populate requests (useful for testing)
+     */
+    addRequests(...requests: UnifiedRequest[]): void;
+}

package/dist/infrastructure/repositories/in-memory/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * In-Memory Repository Implementations
+ * Useful for testing and as fallbacks
+ */
+export * from './in-memory-request-repository';
+export * from './in-memory-environment-repository';
+export * from './in-memory-collection-repository';

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

@@ -0,0 +1,4 @@
+/**
+ * Script Infrastructure Adapters and Implementations
+ */
+export * from './vm-script-executor.adapter';