@scenarist/core 0.0.1 → 0.1.0

package/dist/adapters/in-memory-registry.d.ts

@@ -0,0 +1,18 @@
+import type { ScenarioRegistry } from '../ports/index.js';
+import type { ScenaristScenario } from '../types/index.js';
+/**
+ * In-memory implementation of ScenarioRegistry using a Map.
+ * Suitable for single-process testing and development.
+ *
+ * For distributed testing across multiple processes,
+ * consider implementing a Redis-based or database-backed registry.
+ */
+export declare class InMemoryScenarioRegistry implements ScenarioRegistry {
+    private readonly registry;
+    register(definition: ScenaristScenario): void;
+    get(id: string): ScenaristScenario | undefined;
+    has(id: string): boolean;
+    list(): ReadonlyArray<ScenaristScenario>;
+    unregister(id: string): void;
+}
+//# sourceMappingURL=in-memory-registry.d.ts.map

package/dist/adapters/in-memory-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-registry.d.ts","sourceRoot":"","sources":["../../src/adapters/in-memory-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE3D;;;;;;GAMG;AACH,qBAAa,wBAAyB,YAAW,gBAAgB;IAC/D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAwC;IAEjE,QAAQ,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI;IAI7C,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAI9C,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIxB,IAAI,IAAI,aAAa,CAAC,iBAAiB,CAAC;IAIxC,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;CAG7B"}

package/dist/adapters/in-memory-registry.js

@@ -0,0 +1,25 @@
+/**
+ * In-memory implementation of ScenarioRegistry using a Map.
+ * Suitable for single-process testing and development.
+ *
+ * For distributed testing across multiple processes,
+ * consider implementing a Redis-based or database-backed registry.
+ */
+export class InMemoryScenarioRegistry {
+    registry = new Map();
+    register(definition) {
+        this.registry.set(definition.id, definition);
+    }
+    get(id) {
+        return this.registry.get(id);
+    }
+    has(id) {
+        return this.registry.has(id);
+    }
+    list() {
+        return Array.from(this.registry.values());
+    }
+    unregister(id) {
+        this.registry.delete(id);
+    }
+}

package/dist/adapters/in-memory-sequence-tracker.d.ts

@@ -0,0 +1,28 @@
+import type { SequenceTracker, SequencePosition } from '../ports/driven/sequence-tracker.js';
+/**
+ * In-memory implementation of SequenceTracker.
+ *
+ * Tracks sequence positions using a Map in memory.
+ * Suitable for single-process testing scenarios.
+ *
+ * For distributed testing across multiple processes, use a Redis-based
+ * implementation instead.
+ */
+export declare class InMemorySequenceTracker implements SequenceTracker {
+    private readonly positions;
+    constructor();
+    /**
+     * Generate key for tracking sequence position.
+     * Format: `${testId}:${scenarioId}:${mockIndex}`
+     */
+    private getKey;
+    getPosition(testId: string, scenarioId: string, mockIndex: number): SequencePosition;
+    advance(testId: string, scenarioId: string, mockIndex: number, totalResponses: number, repeatMode: 'last' | 'cycle' | 'none'): void;
+    reset(testId: string): void;
+}
+/**
+ * Create an in-memory sequence tracker.
+ * Factory function following the pattern established for other domain services.
+ */
+export declare const createInMemorySequenceTracker: () => SequenceTracker;
+//# sourceMappingURL=in-memory-sequence-tracker.d.ts.map

package/dist/adapters/in-memory-sequence-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-sequence-tracker.d.ts","sourceRoot":"","sources":["../../src/adapters/in-memory-sequence-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EACjB,MAAM,qCAAqC,CAAC;AAE7C;;;;;;;;GAQG;AACH,qBAAa,uBAAwB,YAAW,eAAe;IAC7D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgC;;IAM1D;;;OAGG;IACH,OAAO,CAAC,MAAM;IAId,WAAW,CACT,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GAChB,gBAAgB;IAYnB,OAAO,CACL,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GACpC,IAAI;IA0CP,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;CAM5B;AAED;;;GAGG;AACH,eAAO,MAAM,6BAA6B,QAAO,eAEhD,CAAC"}

package/dist/adapters/in-memory-sequence-tracker.js

@@ -0,0 +1,82 @@
+/**
+ * In-memory implementation of SequenceTracker.
+ *
+ * Tracks sequence positions using a Map in memory.
+ * Suitable for single-process testing scenarios.
+ *
+ * For distributed testing across multiple processes, use a Redis-based
+ * implementation instead.
+ */
+export class InMemorySequenceTracker {
+    positions;
+    constructor() {
+        this.positions = new Map();
+    }
+    /**
+     * Generate key for tracking sequence position.
+     * Format: `${testId}:${scenarioId}:${mockIndex}`
+     */
+    getKey(testId, scenarioId, mockIndex) {
+        return `${testId}:${scenarioId}:${mockIndex}`;
+    }
+    getPosition(testId, scenarioId, mockIndex) {
+        const key = this.getKey(testId, scenarioId, mockIndex);
+        const existing = this.positions.get(key);
+        // If no position exists yet, start at 0
+        if (!existing) {
+            return { position: 0, exhausted: false };
+        }
+        return existing;
+    }
+    advance(testId, scenarioId, mockIndex, totalResponses, repeatMode) {
+        const key = this.getKey(testId, scenarioId, mockIndex);
+        const current = this.getPosition(testId, scenarioId, mockIndex);
+        const nextPosition = current.position + 1;
+        // Handle different repeat modes
+        if (nextPosition >= totalResponses) {
+            switch (repeatMode) {
+                case 'last':
+                    // Stay at last position (don't increment beyond last)
+                    this.positions.set(key, {
+                        position: totalResponses - 1,
+                        exhausted: false,
+                    });
+                    break;
+                case 'cycle':
+                    // Wrap back to first position
+                    this.positions.set(key, {
+                        position: 0,
+                        exhausted: false,
+                    });
+                    break;
+                case 'none':
+                    // Mark as exhausted
+                    this.positions.set(key, {
+                        position: totalResponses,
+                        exhausted: true,
+                    });
+                    break;
+            }
+        }
+        else {
+            // Normal advancement (not at end yet)
+            this.positions.set(key, {
+                position: nextPosition,
+                exhausted: false,
+            });
+        }
+    }
+    reset(testId) {
+        const prefix = `${testId}:`;
+        Array.from(this.positions.keys())
+            .filter(key => key.startsWith(prefix))
+            .forEach(key => this.positions.delete(key));
+    }
+}
+/**
+ * Create an in-memory sequence tracker.
+ * Factory function following the pattern established for other domain services.
+ */
+export const createInMemorySequenceTracker = () => {
+    return new InMemorySequenceTracker();
+};

package/dist/adapters/in-memory-state-manager.d.ts

@@ -0,0 +1,24 @@
+import type { StateManager } from '../ports/driven/state-manager.js';
+/**
+ * In-memory implementation of StateManager port.
+ * Fast, single-process state storage for stateful mocks.
+ *
+ * For distributed testing across multiple processes,
+ * consider implementing a Redis-based or database-backed state manager.
+ */
+export declare class InMemoryStateManager implements StateManager {
+    private readonly storage;
+    get(testId: string, key: string): unknown;
+    set(testId: string, key: string, value: unknown): void;
+    getAll(testId: string): Record<string, unknown>;
+    reset(testId: string): void;
+    private getOrCreateTestState;
+    private setNestedValue;
+    private getNestedValue;
+}
+/**
+ * Factory function for creating InMemoryStateManager instances.
+ * Consistent with existing adapter factory pattern.
+ */
+export declare const createInMemoryStateManager: () => StateManager;
+//# sourceMappingURL=in-memory-state-manager.d.ts.map

package/dist/adapters/in-memory-state-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-state-manager.d.ts","sourceRoot":"","sources":["../../src/adapters/in-memory-state-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAErE;;;;;;GAMG;AACH,qBAAa,oBAAqB,YAAW,YAAY;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8C;IAEtE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAUzC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAyBtD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAI/C,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI3B,OAAO,CAAC,oBAAoB;IAS5B,OAAO,CAAC,cAAc;IActB,OAAO,CAAC,cAAc;CAavB;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,QAAO,YAE7C,CAAC"}

package/dist/adapters/in-memory-state-manager.js

@@ -0,0 +1,81 @@
+/**
+ * In-memory implementation of StateManager port.
+ * Fast, single-process state storage for stateful mocks.
+ *
+ * For distributed testing across multiple processes,
+ * consider implementing a Redis-based or database-backed state manager.
+ */
+export class InMemoryStateManager {
+    storage = new Map();
+    get(testId, key) {
+        const testState = this.storage.get(testId);
+        if (!testState) {
+            return undefined;
+        }
+        const path = key.split('.');
+        return this.getNestedValue(testState, path);
+    }
+    set(testId, key, value) {
+        const testState = this.getOrCreateTestState(testId);
+        // Guard: Normal set (no array syntax)
+        if (!key.endsWith('[]')) {
+            const path = key.split('.');
+            this.setNestedValue(testState, path, value);
+            return;
+        }
+        // Array append syntax
+        const actualKey = key.slice(0, -2);
+        const path = actualKey.split('.');
+        const currentValue = this.get(testId, actualKey);
+        // Guard: If current value is already an array, append immutably
+        if (Array.isArray(currentValue)) {
+            this.setNestedValue(testState, path, [...currentValue, value]);
+            return;
+        }
+        // Create new array (either undefined or non-array value)
+        this.setNestedValue(testState, path, [value]);
+    }
+    getAll(testId) {
+        return this.storage.get(testId) ?? {};
+    }
+    reset(testId) {
+        this.storage.delete(testId);
+    }
+    getOrCreateTestState(testId) {
+        let testState = this.storage.get(testId);
+        if (!testState) {
+            testState = {};
+            this.storage.set(testId, testState);
+        }
+        return testState;
+    }
+    setNestedValue(obj, path, value) {
+        if (path.length === 1) {
+            obj[path[0]] = value;
+            return;
+        }
+        const key = path[0];
+        if (typeof obj[key] !== 'object' || obj[key] === null || Array.isArray(obj[key])) {
+            obj[key] = {};
+        }
+        this.setNestedValue(obj[key], path.slice(1), value);
+    }
+    getNestedValue(obj, path) {
+        if (path.length === 1) {
+            return obj[path[0]];
+        }
+        const key = path[0];
+        const nested = obj[key];
+        if (typeof nested !== 'object' || nested === null || Array.isArray(nested)) {
+            return undefined;
+        }
+        return this.getNestedValue(nested, path.slice(1));
+    }
+}
+/**
+ * Factory function for creating InMemoryStateManager instances.
+ * Consistent with existing adapter factory pattern.
+ */
+export const createInMemoryStateManager = () => {
+    return new InMemoryStateManager();
+};

package/dist/adapters/in-memory-store.d.ts

@@ -0,0 +1,18 @@
+import type { ScenarioStore } from '../ports/index.js';
+import type { ActiveScenario } from '../types/index.js';
+/**
+ * In-memory implementation of ScenarioStore using a Map.
+ * Suitable for single-process testing.
+ *
+ * For distributed testing across multiple processes,
+ * consider implementing a Redis-based store.
+ */
+export declare class InMemoryScenarioStore implements ScenarioStore {
+    private readonly store;
+    set(testId: string, scenario: ActiveScenario): void;
+    get(testId: string): ActiveScenario | undefined;
+    has(testId: string): boolean;
+    delete(testId: string): void;
+    clear(): void;
+}
+//# sourceMappingURL=in-memory-store.d.ts.map

package/dist/adapters/in-memory-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-store.d.ts","sourceRoot":"","sources":["../../src/adapters/in-memory-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD;;;;;;GAMG;AACH,qBAAa,qBAAsB,YAAW,aAAa;IACzD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqC;IAE3D,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI;IAInD,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAI/C,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAI5B,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI5B,KAAK,IAAI,IAAI;CAGd"}

package/dist/adapters/in-memory-store.js

@@ -0,0 +1,25 @@
+/**
+ * In-memory implementation of ScenarioStore using a Map.
+ * Suitable for single-process testing.
+ *
+ * For distributed testing across multiple processes,
+ * consider implementing a Redis-based store.
+ */
+export class InMemoryScenarioStore {
+    store = new Map();
+    set(testId, scenario) {
+        this.store.set(testId, scenario);
+    }
+    get(testId) {
+        return this.store.get(testId);
+    }
+    has(testId) {
+        return this.store.has(testId);
+    }
+    delete(testId) {
+        this.store.delete(testId);
+    }
+    clear() {
+        this.store.clear();
+    }
+}

package/dist/adapters/index.d.ts

@@ -0,0 +1,5 @@
+export { InMemoryScenarioRegistry } from './in-memory-registry.js';
+export { InMemoryScenarioStore } from './in-memory-store.js';
+export { InMemorySequenceTracker, createInMemorySequenceTracker } from './in-memory-sequence-tracker.js';
+export { InMemoryStateManager, createInMemoryStateManager } from './in-memory-state-manager.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,EAAE,uBAAuB,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AACzG,OAAO,EAAE,oBAAoB,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/adapters/index.js

@@ -0,0 +1,4 @@
+export { InMemoryScenarioRegistry } from './in-memory-registry.js';
+export { InMemoryScenarioStore } from './in-memory-store.js';
+export { InMemorySequenceTracker, createInMemorySequenceTracker } from './in-memory-sequence-tracker.js';
+export { InMemoryStateManager, createInMemoryStateManager } from './in-memory-state-manager.js';

package/dist/constants/headers.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The standard header name used for test ID isolation.
+ *
+ * This header is used by Scenarist to identify which test a request belongs to,
+ * enabling concurrent tests with different backend states.
+ *
+ * This is a fixed constant - not configurable by users.
+ */
+export declare const SCENARIST_TEST_ID_HEADER = "x-scenarist-test-id";
+//# sourceMappingURL=headers.d.ts.map

package/dist/constants/headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../../src/constants/headers.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,wBAAwB,CAAC"}

package/dist/constants/headers.js

@@ -0,0 +1,9 @@
+/**
+ * The standard header name used for test ID isolation.
+ *
+ * This header is used by Scenarist to identify which test a request belongs to,
+ * enabling concurrent tests with different backend states.
+ *
+ * This is a fixed constant - not configurable by users.
+ */
+export const SCENARIST_TEST_ID_HEADER = 'x-scenarist-test-id';

package/dist/constants/index.d.ts

@@ -0,0 +1,2 @@
+export { SCENARIST_TEST_ID_HEADER } from './headers.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/constants/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/constants/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC"}

package/dist/constants/index.js

@@ -0,0 +1 @@
+export { SCENARIST_TEST_ID_HEADER } from './headers.js';

package/dist/contracts/framework-adapter.d.ts

@@ -0,0 +1,118 @@
+import type { ScenaristScenario, ActiveScenario, ScenaristResult, ScenaristConfigInput, ScenaristConfig, ScenaristScenarios, ScenarioIds } from '../types/index.js';
+import type { ScenarioRegistry } from '../ports/driven/scenario-registry.js';
+import type { ScenarioStore } from '../ports/driven/scenario-store.js';
+/**
+ * Base configuration options that all framework adapters must support.
+ *
+ * Extends ScenaristConfigInput (the core config) with adapter-specific options
+ * for registry and store injection.
+ *
+ * Framework adapters can extend this further with framework-specific options:
+ *
+ * @example
+ * ```typescript
+ * // Express adapter - uses base options directly
+ * export type ExpressAdapterOptions<T extends ScenaristScenarios = ScenaristScenarios> =
+ *   BaseAdapterOptions<T>;
+ *
+ * // Fastify adapter - adds framework-specific options
+ * export type FastifyAdapterOptions<T extends ScenaristScenarios = ScenaristScenarios> =
+ *   BaseAdapterOptions<T> & {
+ *     readonly logLevel?: 'debug' | 'info' | 'warn' | 'error';
+ *   };
+ * ```
+ */
+export type BaseAdapterOptions<T extends ScenaristScenarios = ScenaristScenarios> = ScenaristConfigInput<T> & {
+    /**
+     * Custom scenario registry implementation.
+     *
+     * If not provided, InMemoryScenarioRegistry will be used.
+     */
+    readonly registry?: ScenarioRegistry;
+    /**
+     * Custom scenario store implementation.
+     *
+     * If not provided, InMemoryScenarioStore will be used.
+     */
+    readonly store?: ScenarioStore;
+};
+/**
+ * The contract that all Scenarist adapters must satisfy.
+ *
+ * This ensures consistent API across Express, Fastify, Next.js, etc.
+ *
+ * @template TMiddleware - Framework-specific middleware type
+ *   - Express: Router
+ *   - Fastify: FastifyPluginCallback
+ *   - Next.js: NextMiddleware
+ * @template TScenarios - Scenarios object for type-safe scenario IDs
+ */
+export type ScenaristAdapter<TMiddleware = unknown, TScenarios extends ScenaristScenarios = ScenaristScenarios> = {
+    /**
+     * Resolved configuration.
+     *
+     * Use this to access configured endpoints in tests.
+     *
+     * @example
+     * ```typescript
+     * import { SCENARIST_TEST_ID_HEADER } from '@scenarist/core';
+     *
+     * await request(app)
+     *   .post(scenarist.config.endpoints.setScenario)
+     *   .set(SCENARIST_TEST_ID_HEADER, 'test-123')
+     *   .send({ scenario: 'cartWithState' });
+     * ```
+     */
+    readonly config: ScenaristConfig;
+    /**
+     * Framework-specific middleware/plugin.
+     *
+     * - Express: app.use(scenarist.middleware)
+     * - Fastify: app.register(scenarist.middleware)
+     * - Next.js: export const middleware = scenarist.middleware
+     */
+    readonly middleware: TMiddleware;
+    /**
+     * Switch active scenario for a test ID.
+     *
+     * Scenario IDs are type-safe based on the scenarios object passed during creation.
+     *
+     * @example
+     * ```typescript
+     * const result = scenarist.switchScenario('test-123', 'cartWithState');
+     * // TypeScript ensures 'cartWithState' is a valid scenario ID
+     * ```
+     */
+    readonly switchScenario: (testId: string, scenarioId: ScenarioIds<TScenarios>) => ScenaristResult<void, Error>;
+    /**
+     * Get the active scenario for a test ID.
+     */
+    readonly getActiveScenario: (testId: string) => ActiveScenario | undefined;
+    /**
+     * Get a scenario definition by ID.
+     *
+     * Scenario IDs are type-safe based on the scenarios object.
+     */
+    readonly getScenarioById: (scenarioId: ScenarioIds<TScenarios>) => ScenaristScenario | undefined;
+    /**
+     * List all registered scenarios.
+     */
+    readonly listScenarios: () => ReadonlyArray<ScenaristScenario>;
+    /**
+     * Clear the active scenario for a test ID.
+     */
+    readonly clearScenario: (testId: string) => void;
+    /**
+     * Start the MSW server.
+     *
+     * Call in beforeAll() hook.
+     */
+    readonly start: () => void;
+    /**
+     * Stop the MSW server.
+     *
+     * Call in afterAll() hook.
+     */
+    readonly stop: () => Promise<void>;
+};
+//# sourceMappingURL=framework-adapter.d.ts.map

package/dist/contracts/framework-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework-adapter.d.ts","sourceRoot":"","sources":["../../src/contracts/framework-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,oBAAoB,EACpB,eAAe,EACf,kBAAkB,EAClB,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAC7E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,kBAAkB,GAAG,kBAAkB,IAC9E,oBAAoB,CAAC,CAAC,CAAC,GAAG;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAErC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;CAChC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,gBAAgB,CAC1B,WAAW,GAAG,OAAO,EACrB,UAAU,SAAS,kBAAkB,GAAG,kBAAkB,IACxD;IACF;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IAEjC;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC;IAEjC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,cAAc,EAAE,CACvB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,WAAW,CAAC,UAAU,CAAC,KAChC,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAElC;;OAEG;IACH,QAAQ,CAAC,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,cAAc,GAAG,SAAS,CAAC;IAE3E;;;;OAIG;IACH,QAAQ,CAAC,eAAe,EAAE,CACxB,UAAU,EAAE,WAAW,CAAC,UAAU,CAAC,KAChC,iBAAiB,GAAG,SAAS,CAAC;IAEnC;;OAEG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,aAAa,CAAC,iBAAiB,CAAC,CAAC;IAE/D;;OAEG;IACH,QAAQ,CAAC,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAEjD;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAE3B;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACpC,CAAC"}

package/dist/contracts/framework-adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/index.d.ts

@@ -0,0 +1,2 @@
+export type { ScenaristAdapter, BaseAdapterOptions, } from './framework-adapter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/contracts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":"AAGA,YAAY,EACV,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,wBAAwB,CAAC"}

package/dist/contracts/index.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/config-builder.d.ts

@@ -0,0 +1,9 @@
+import type { ScenaristConfig, ScenaristConfigInput, ScenaristScenarios } from '../types/index.js';
+/**
+ * Build a complete config from partial user input.
+ * Applies sensible defaults for missing values.
+ *
+ * **Validation:** Ensures scenarios object has a 'default' key.
+ */
+export declare const buildConfig: <T extends ScenaristScenarios>(input: ScenaristConfigInput<T>) => ScenaristConfig;
+//# sourceMappingURL=config-builder.d.ts.map

package/dist/domain/config-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-builder.d.ts","sourceRoot":"","sources":["../../src/domain/config-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAGnG;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,kBAAkB,EACtD,OAAO,oBAAoB,CAAC,CAAC,CAAC,KAC7B,eAaF,CAAC"}

package/dist/domain/config-builder.js

@@ -0,0 +1,20 @@
+import { ScenariosObjectSchema } from '../schemas/index.js';
+/**
+ * Build a complete config from partial user input.
+ * Applies sensible defaults for missing values.
+ *
+ * **Validation:** Ensures scenarios object has a 'default' key.
+ */
+export const buildConfig = (input) => {
+    // Validate scenarios object has 'default' key (trust boundary)
+    ScenariosObjectSchema.parse(input.scenarios);
+    return {
+        enabled: input.enabled,
+        strictMode: input.strictMode ?? false,
+        endpoints: {
+            setScenario: input.endpoints?.setScenario ?? '/__scenario__',
+            getScenario: input.endpoints?.getScenario ?? '/__scenario__',
+        },
+        defaultTestId: input.defaultTestId ?? 'default-test',
+    };
+};

package/dist/domain/index.d.ts

@@ -0,0 +1,5 @@
+export { createScenarioManager } from './scenario-manager.js';
+export { buildConfig } from './config-builder.js';
+export { createResponseSelector } from './response-selector.js';
+export { matchesRegex } from './regex-matching.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/domain/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/domain/index.js

@@ -0,0 +1,4 @@
+export { createScenarioManager } from './scenario-manager.js';
+export { buildConfig } from './config-builder.js';
+export { createResponseSelector } from './response-selector.js';
+export { matchesRegex } from './regex-matching.js';

package/dist/domain/path-extraction.d.ts

@@ -0,0 +1,17 @@
+import type { HttpRequestContext } from '../types/scenario.js';
+/**
+ * Extracts a value from HttpRequestContext based on a path expression.
+ *
+ * Supported path prefixes:
+ * - `body.field` - Extract from request body
+ * - `headers.field` - Extract from request headers
+ * - `query.field` - Extract from query parameters
+ *
+ * Supports nested paths: `body.user.profile.name`
+ *
+ * @param context - HTTP request context
+ * @param path - Path expression (e.g., 'body.userId', 'headers.x-session-id')
+ * @returns Extracted value, or undefined if path not found
+ */
+export declare const extractFromPath: (context: HttpRequestContext, path: string) => unknown;
+//# sourceMappingURL=path-extraction.d.ts.map

package/dist/domain/path-extraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-extraction.d.ts","sourceRoot":"","sources":["../../src/domain/path-extraction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,kBAAkB,EAAE,MAAM,MAAM,KAAG,OA+B3E,CAAC"}

package/dist/domain/path-extraction.js

@@ -0,0 +1,60 @@
+/**
+ * Extracts a value from HttpRequestContext based on a path expression.
+ *
+ * Supported path prefixes:
+ * - `body.field` - Extract from request body
+ * - `headers.field` - Extract from request headers
+ * - `query.field` - Extract from query parameters
+ *
+ * Supports nested paths: `body.user.profile.name`
+ *
+ * @param context - HTTP request context
+ * @param path - Path expression (e.g., 'body.userId', 'headers.x-session-id')
+ * @returns Extracted value, or undefined if path not found
+ */
+export const extractFromPath = (context, path) => {
+    const segments = path.split('.');
+    // Guard: Need at least 2 segments (prefix.field)
+    if (segments.length < 2) {
+        return undefined;
+    }
+    const prefix = segments[0];
+    // Guard: Must be valid prefix
+    if (prefix !== 'body' && prefix !== 'headers' && prefix !== 'query') {
+        return undefined;
+    }
+    const remainingPath = segments.slice(1);
+    const sourceMap = {
+        body: context.body,
+        headers: context.headers,
+        query: context.query,
+    };
+    const source = sourceMap[prefix];
+    // Guard: Source must exist
+    if (source === undefined || source === null) {
+        return undefined;
+    }
+    return traversePath(source, remainingPath);
+};
+/**
+ * Traverses a nested object path.
+ *
+ * @param obj - Object to traverse
+ * @param path - Path segments to follow
+ * @returns Value at path, or undefined if not found
+ */
+const traversePath = (obj, path) => {
+    // Guard: Empty path means we've reached the value
+    if (path.length === 0) {
+        return obj;
+    }
+    // Guard: Can only traverse objects
+    if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+        return undefined;
+    }
+    const key = path[0];
+    const record = obj;
+    const value = record[key];
+    // Recursively traverse remaining path
+    return traversePath(value, path.slice(1));
+};