@scenarist/core 0.0.1 → 0.1.0

package/dist/ports/driven/request-context.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Secondary port for extracting context from HTTP requests.
+ * Framework adapters implement this to provide test ID extraction.
+ *
+ * **Implementation Pattern:**
+ * Implementations should accept ScenaristConfig to determine which headers
+ * to read and what defaults to apply.
+ *
+ * @example
+ * ```typescript
+ * import { SCENARIST_TEST_ID_HEADER } from '@scenarist/core';
+ *
+ * class ExpressRequestContext implements RequestContext {
+ *   constructor(
+ *     private readonly req: Request,
+ *     private readonly defaultTestId: string
+ *   ) {}
+ *
+ *   getTestId(): string {
+ *     const header = this.req.headers[SCENARIST_TEST_ID_HEADER];
+ *     return typeof header === 'string' ? header : this.defaultTestId;
+ *   }
+ * }
+ * ```
+ */
+export interface RequestContext {
+    /**
+     * Extract the test ID from the request.
+     * This enables test isolation.
+     */
+    getTestId(): string;
+    /**
+     * Get all request headers.
+     * Useful for debugging and logging.
+     */
+    getHeaders(): Record<string, string | string[] | undefined>;
+    /**
+     * Get the request hostname.
+     * Used to determine passthrough behavior.
+     */
+    getHostname(): string;
+}
+//# sourceMappingURL=request-context.d.ts.map

package/dist/ports/driven/request-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-context.d.ts","sourceRoot":"","sources":["../../../src/ports/driven/request-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,SAAS,IAAI,MAAM,CAAC;IAEpB;;;OAGG;IACH,UAAU,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC;IAE5D;;;OAGG;IACH,WAAW,IAAI,MAAM,CAAC;CACvB"}

package/dist/ports/driven/request-context.js

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

package/dist/ports/driven/response-selector.d.ts

@@ -0,0 +1,34 @@
+import type { ScenaristMockWithParams, ScenaristResponse, HttpRequestContext, ScenaristResult } from "../../types/index.js";
+/**
+ * Error type for response selection failures.
+ */
+export declare class ResponseSelectionError extends Error {
+    constructor(message: string);
+}
+/**
+ * Secondary port for response selection.
+ * Determines which mock response to return based on request content.
+ *
+ * Phase 1 (Current): Stateless matching on body/headers/query
+ * Phase 2 (Future): Sequence tracking (first call, second call, etc.)
+ * Phase 3 (Future): Stateful responses (increment counters, etc.)
+ *
+ * The interface is defined as a port to allow:
+ * - Default implementation: Stateless content matching (createResponseSelector)
+ * - Sequence-aware implementation: Track call counts per mock
+ * - State-aware implementation: Maintain state across requests
+ * - Test doubles: Mock response selection for adapter tests
+ */
+export interface ResponseSelector {
+    /**
+     * Select a response from candidate mocks based on request content.
+     *
+     * @param testId - Test ID for sequence/state tracking
+     * @param scenarioId - Scenario ID for sequence/state tracking
+     * @param context - Request context (method, url, body, headers, query)
+     * @param mocks - Candidate mocks with extracted params (already filtered by URL/method)
+     * @returns ScenaristResult with selected ScenaristResponse or error if no match found
+     */
+    selectResponse(testId: string, scenarioId: string, context: HttpRequestContext, mocks: ReadonlyArray<ScenaristMockWithParams>): ScenaristResult<ScenaristResponse, ResponseSelectionError>;
+}
+//# sourceMappingURL=response-selector.d.ts.map

package/dist/ports/driven/response-selector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-selector.d.ts","sourceRoot":"","sources":["../../../src/ports/driven/response-selector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EACvB,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAE9B;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,KAAK;gBACnC,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;;OAQG;IACH,cAAc,CACZ,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,aAAa,CAAC,uBAAuB,CAAC,GAC5C,eAAe,CAAC,iBAAiB,EAAE,sBAAsB,CAAC,CAAC;CAC/D"}

package/dist/ports/driven/response-selector.js

@@ -0,0 +1,9 @@
+/**
+ * Error type for response selection failures.
+ */
+export class ResponseSelectionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ResponseSelectionError";
+    }
+}

package/dist/ports/driven/scenario-registry.d.ts

@@ -0,0 +1,46 @@
+import type { ScenaristScenario } from '../../types/index.js';
+/**
+ * Secondary port for scenario registry.
+ * Manages the catalog of available scenarios.
+ *
+ * This is separate from ScenarioStore to maintain architectural purity:
+ * - ScenarioRegistry: what scenarios exist (the catalog)
+ * - ScenarioStore: which scenario each test is using (active state)
+ *
+ * ScenarioDefinitions are serializable, enabling:
+ * - InMemoryScenarioRegistry: Map-based registry (default, fastest)
+ * - RedisScenarioRegistry: Distributed scenarios across processes
+ * - FileSystemScenarioRegistry: Load scenarios from JSON/YAML files
+ * - RemoteScenarioRegistry: Fetch scenarios from REST API
+ * - DatabaseScenarioRegistry: Store scenarios in PostgreSQL/MongoDB
+ *
+ * At runtime, ScenaristMocks are converted to MSW HttpHandlers.
+ */
+export interface ScenarioRegistry {
+    /**
+     * Register a scenario definition.
+     * The definition.id is used as the unique identifier.
+     * Makes the scenario available for use.
+     */
+    register(definition: ScenaristScenario): void;
+    /**
+     * Retrieve a registered scenario definition by ID.
+     * Returns undefined if scenario not found.
+     */
+    get(id: string): ScenaristScenario | undefined;
+    /**
+     * Check if a scenario ID is registered.
+     */
+    has(id: string): boolean;
+    /**
+     * List all registered scenario definitions.
+     * Useful for debugging, dev tools, and scenario discovery.
+     */
+    list(): ReadonlyArray<ScenaristScenario>;
+    /**
+     * Remove a scenario from the registry.
+     * Does not affect already-active scenarios in the store.
+     */
+    unregister(id: string): void;
+}
+//# sourceMappingURL=scenario-registry.d.ts.map

package/dist/ports/driven/scenario-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scenario-registry.d.ts","sourceRoot":"","sources":["../../../src/ports/driven/scenario-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAE9C;;;OAGG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAAC;IAE/C;;OAEG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAEzB;;;OAGG;IACH,IAAI,IAAI,aAAa,CAAC,iBAAiB,CAAC,CAAC;IAEzC;;;OAGG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B"}

package/dist/ports/driven/scenario-registry.js

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

package/dist/ports/driven/scenario-store.d.ts

@@ -0,0 +1,33 @@
+import type { ActiveScenario } from '../../types/index.js';
+/**
+ * Secondary port for scenario storage.
+ * Implementations determine where active scenarios are stored.
+ *
+ * Examples:
+ * - InMemoryScenarioStore: Map-based storage (single process)
+ * - RedisScenarioStore: Redis-based storage (distributed tests)
+ */
+export interface ScenarioStore {
+    /**
+     * Store an active scenario for a test ID.
+     */
+    set(testId: string, scenario: ActiveScenario): void;
+    /**
+     * Retrieve an active scenario for a test ID.
+     */
+    get(testId: string): ActiveScenario | undefined;
+    /**
+     * Check if a test ID has an active scenario.
+     */
+    has(testId: string): boolean;
+    /**
+     * Remove the active scenario for a test ID.
+     */
+    delete(testId: string): void;
+    /**
+     * Clear all active scenarios.
+     * Use with caution - affects all test IDs.
+     */
+    clear(): void;
+}
+//# sourceMappingURL=scenario-store.d.ts.map

package/dist/ports/driven/scenario-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scenario-store.d.ts","sourceRoot":"","sources":["../../../src/ports/driven/scenario-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAC;IAEpD;;OAEG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAAC;IAEhD;;OAEG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IAE7B;;OAEG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAE7B;;;OAGG;IACH,KAAK,IAAI,IAAI,CAAC;CACf"}

package/dist/ports/driven/scenario-store.js

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

package/dist/ports/driven/sequence-tracker.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Sequence position state for a specific mock.
+ */
+export type SequencePosition = {
+    readonly position: number;
+    readonly exhausted: boolean;
+};
+/**
+ * Secondary port for sequence position tracking.
+ *
+ * Tracks which response in a sequence should be returned next for each
+ * (testId + scenarioId + mockIndex) combination.
+ *
+ * This port enables:
+ * - Default implementation: In-memory tracking (Map-based)
+ * - Redis implementation: Distributed testing across processes
+ * - File-based implementation: Persistent state across restarts
+ * - Test doubles: Mock sequence tracking for adapter tests
+ */
+export interface SequenceTracker {
+    /**
+     * Get the current sequence position for a specific mock.
+     *
+     * @param testId - Test ID for isolation
+     * @param scenarioId - Scenario ID
+     * @param mockIndex - Index of the mock in the scenario's mocks array
+     * @returns Current position (0-indexed) and exhaustion status
+     */
+    getPosition(testId: string, scenarioId: string, mockIndex: number): SequencePosition;
+    /**
+     * Advance the sequence position for a specific mock.
+     *
+     * @param testId - Test ID for isolation
+     * @param scenarioId - Scenario ID
+     * @param mockIndex - Index of the mock in the scenario's mocks array
+     * @param totalResponses - Total number of responses in the sequence
+     * @param repeatMode - Repeat behavior ('last' | 'cycle' | 'none')
+     */
+    advance(testId: string, scenarioId: string, mockIndex: number, totalResponses: number, repeatMode: 'last' | 'cycle' | 'none'): void;
+    /**
+     * Reset all sequence positions for a specific test ID.
+     *
+     * Called when switching scenarios to ensure sequences start fresh.
+     *
+     * @param testId - Test ID to reset
+     */
+    reset(testId: string): void;
+}
+//# sourceMappingURL=sequence-tracker.d.ts.map

package/dist/ports/driven/sequence-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequence-tracker.d.ts","sourceRoot":"","sources":["../../../src/ports/driven/sequence-tracker.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;;OAOG;IACH,WAAW,CACT,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GAChB,gBAAgB,CAAC;IAEpB;;;;;;;;OAQG;IACH,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,CAAC;IAER;;;;;;OAMG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B"}

package/dist/ports/driven/sequence-tracker.js

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

package/dist/ports/driven/state-manager.d.ts

@@ -0,0 +1,56 @@
+/**
+ * StateManager port for managing runtime state in stateful mocks (Phase 3).
+ *
+ * Implementations store state per test ID, enabling:
+ * - Capturing values from requests
+ * - Injecting state into responses via templates
+ * - State isolation between concurrent tests
+ *
+ * State values MUST be JSON-serializable to support distributed implementations:
+ * - ✅ Primitives: string, number, boolean, null
+ * - ✅ Objects and arrays (plain data)
+ * - ❌ Functions, classes, symbols, undefined, circular references
+ *
+ * This enables multiple implementations:
+ * - InMemoryStateManager (default): Fast, single-process
+ * - RedisStateManager (future): Distributed testing
+ * - FileSystemStateManager (future): Persistent state
+ */
+export interface StateManager {
+    /**
+     * Get a state value for a specific test ID.
+     *
+     * @param testId - Test identifier for state isolation
+     * @param key - State key (can be nested path like 'user.profile.name')
+     * @returns Value from state, or undefined if not found
+     */
+    get(testId: string, key: string): unknown;
+    /**
+     * Set a state value for a specific test ID.
+     *
+     * @param testId - Test identifier for state isolation
+     * @param key - State key (supports nested paths)
+     * @param value - Value to store (must be JSON-serializable)
+     */
+    set(testId: string, key: string, value: unknown): void;
+    /**
+     * Get all state for a specific test ID.
+     *
+     * @param testId - Test identifier
+     * @returns Complete state object for this test ID
+     */
+    getAll(testId: string): Record<string, unknown>;
+    /**
+     * Reset all state for a specific test ID.
+     *
+     * Called automatically by ScenarioManager when switching scenarios to prevent
+     * state pollution between scenarios. Tests may also call this manually to reset
+     * state mid-test.
+     *
+     * Note: New test IDs start with empty state automatically (no reset needed).
+     *
+     * @param testId - Test identifier
+     */
+    reset(testId: string): void;
+}
+//# sourceMappingURL=state-manager.d.ts.map

package/dist/ports/driven/state-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-manager.d.ts","sourceRoot":"","sources":["../../../src/ports/driven/state-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;;OAMG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAE1C;;;;;;OAMG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAEvD;;;;;OAKG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEhD;;;;;;;;;;OAUG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B"}

package/dist/ports/driven/state-manager.js

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

package/dist/ports/driving/scenario-manager.d.ts

@@ -0,0 +1,99 @@
+import type { ScenaristScenario, ActiveScenario, ScenaristResult } from '../../types/index.js';
+/**
+ * Primary port for scenario management.
+ *
+ * ScenarioManager is a coordinator/facade that orchestrates interactions between
+ * ScenarioRegistry (catalog of available scenarios) and ScenarioStore (active
+ * scenarios per test ID). It enforces business rules and provides a unified API.
+ *
+ * **Architectural Role:**
+ * - Coordinates between registry and store
+ * - Enforces business rules (e.g., can't activate non-existent scenarios)
+ * - Provides test isolation via test IDs
+ * - Main entry point for scenario operations
+ *
+ * **Implementation Pattern:**
+ * Implementations accept ScenarioRegistry and ScenarioStore as constructor
+ * parameters (dependency injection), never creating them internally.
+ *
+ * Note: Config is NOT needed here - it's used by adapters (middleware, RequestContext)
+ * to handle HTTP concerns. ScenarioManager is pure domain logic.
+ *
+ * @example
+ * ```typescript
+ * // Factory function accepts both ports as dependencies
+ * const manager = createScenarioManager({
+ *   registry: new InMemoryScenarioRegistry(),
+ *   store: new InMemoryScenarioStore(),
+ * });
+ * ```
+ *
+ * **Thread Safety:**
+ * Implementations must be thread-safe for concurrent test execution.
+ */
+export interface ScenarioManager {
+    /**
+     * Register a scenario definition in the catalog.
+     *
+     * Delegates to: ScenarioRegistry.register()
+     *
+     * @param definition The scenario definition to register
+     * @throws Error if scenario ID is already registered
+     */
+    registerScenario(definition: ScenaristScenario): void;
+    /**
+     * Switch to a different scenario for a specific test ID.
+     *
+     * Business rule: Validates scenario exists in registry before activating.
+     * Delegates to: ScenarioRegistry.get() then ScenarioStore.set()
+     *
+     * This enables test isolation - different tests can run different scenarios.
+     *
+     * @param testId Unique identifier for the test
+     * @param scenarioId ID of the scenario to activate
+     * @returns Success or error if scenario not found in registry
+     */
+    switchScenario(testId: string, scenarioId: string): ScenaristResult<void, Error>;
+    /**
+     * Get the currently active scenario reference for a test ID.
+     *
+     * Delegates to: ScenarioStore.get()
+     *
+     * Note: This returns only the reference (scenarioId).
+     * To get the full ScenarioDefinition, use getScenarioById().
+     *
+     * @param testId Unique identifier for the test
+     * @returns Active scenario reference or undefined if no scenario active
+     */
+    getActiveScenario(testId: string): ActiveScenario | undefined;
+    /**
+     * List all registered scenario definitions from the catalog.
+     *
+     * Delegates to: ScenarioRegistry.list()
+     *
+     * Useful for debugging and dev tools.
+     *
+     * @returns Array of all registered scenario definitions
+     */
+    listScenarios(): ReadonlyArray<ScenaristScenario>;
+    /**
+     * Clear the active scenario for a specific test ID.
+     *
+     * Delegates to: ScenarioStore.delete()
+     *
+     * Useful for cleanup after tests.
+     *
+     * @param testId Unique identifier for the test
+     */
+    clearScenario(testId: string): void;
+    /**
+     * Get a registered scenario definition by ID without activating it.
+     *
+     * Delegates to: ScenarioRegistry.get()
+     *
+     * @param id Scenario definition ID
+     * @returns Scenario definition or undefined if not found
+     */
+    getScenarioById(id: string): ScenaristScenario | undefined;
+}
+//# sourceMappingURL=scenario-manager.d.ts.map

package/dist/ports/driving/scenario-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scenario-manager.d.ts","sourceRoot":"","sources":["../../../src/ports/driving/scenario-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE/F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;;OAOG;IACH,gBAAgB,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAEtD;;;;;;;;;;;OAWG;IACH,cAAc,CACZ,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,GACjB,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAEhC;;;;;;;;;;OAUG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAAC;IAE9D;;;;;;;;OAQG;IACH,aAAa,IAAI,aAAa,CAAC,iBAAiB,CAAC,CAAC;IAElD;;;;;;;;OAQG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAEpC;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAAC;CAC5D"}

package/dist/ports/driving/scenario-manager.js

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

package/dist/ports/index.d.ts

@@ -0,0 +1,8 @@
+export type { ScenarioManager } from './driving/scenario-manager.js';
+export type { ScenarioRegistry } from './driven/scenario-registry.js';
+export type { ScenarioStore } from './driven/scenario-store.js';
+export type { RequestContext } from './driven/request-context.js';
+export type { ResponseSelector } from './driven/response-selector.js';
+export type { SequenceTracker, SequencePosition } from './driven/sequence-tracker.js';
+export type { StateManager } from './driven/state-manager.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ports/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAGrE,YAAY,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACtE,YAAY,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,YAAY,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,YAAY,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACtE,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACtF,YAAY,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/ports/index.js

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

package/dist/schemas/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Runtime validation schemas for domain data.
+ *
+ * **Architectural Principle:**
+ * Schemas in this directory define domain validation rules.
+ * Framework adapters use these schemas at trust boundaries (external → internal).
+ *
+ * **Pattern:**
+ * 1. Define schema using Zod
+ * 2. Export both schema and derived type
+ * 3. Adapters import and apply at trust boundaries
+ * 4. NEVER duplicate schemas in adapters
+ */
+export { ScenarioRequestSchema, type ScenarioRequest } from './scenario-requests.js';
+export { ScenariosObjectSchema } from './scenarios-object.js';
+export { HttpMethodSchema, ScenaristResponseSchema, MatchValueSchema, ScenaristMatchSchema, RepeatModeSchema, ScenaristSequenceSchema, ScenaristCaptureConfigSchema, ScenaristUrlPatternSchema, ScenaristMockSchema, ScenaristScenarioSchema, type HttpMethod, type ScenaristResponse, type MatchValue, type ScenaristMatch, type RepeatMode, type ScenaristSequence, type ScenaristCaptureConfig, type ScenaristUrlPattern, type ScenaristMock, type ScenaristScenario, } from './scenario-definition.js';
+export { SerializedRegexSchema, type SerializedRegex } from './match-criteria.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,qBAAqB,EAAE,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACrF,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EACL,gBAAgB,EAChB,uBAAuB,EACvB,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,uBAAuB,EACvB,4BAA4B,EAC5B,yBAAyB,EACzB,mBAAmB,EACnB,uBAAuB,EAEvB,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,KAAK,iBAAiB,GACvB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,qBAAqB,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/schemas/index.js

@@ -0,0 +1,17 @@
+/**
+ * Runtime validation schemas for domain data.
+ *
+ * **Architectural Principle:**
+ * Schemas in this directory define domain validation rules.
+ * Framework adapters use these schemas at trust boundaries (external → internal).
+ *
+ * **Pattern:**
+ * 1. Define schema using Zod
+ * 2. Export both schema and derived type
+ * 3. Adapters import and apply at trust boundaries
+ * 4. NEVER duplicate schemas in adapters
+ */
+export { ScenarioRequestSchema } from './scenario-requests.js';
+export { ScenariosObjectSchema } from './scenarios-object.js';
+export { HttpMethodSchema, ScenaristResponseSchema, MatchValueSchema, ScenaristMatchSchema, RepeatModeSchema, ScenaristSequenceSchema, ScenaristCaptureConfigSchema, ScenaristUrlPatternSchema, ScenaristMockSchema, ScenaristScenarioSchema, } from './scenario-definition.js';
+export { SerializedRegexSchema } from './match-criteria.js';

package/dist/schemas/match-criteria.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+/**
+ * Schema for serialized regex patterns.
+ *
+ * **Security Notes:**
+ * - Uses redos-detector to prevent ReDoS attacks
+ * - Validates regex flags to prevent injection
+ * - Source must be non-empty string
+ *
+ * **Serialization:**
+ * Regex patterns are serialized as plain objects to maintain JSON compatibility.
+ * This allows scenarios to be stored in files, databases, or transmitted over network.
+ *
+ * @example
+ * ```typescript
+ * const regex: SerializedRegex = {
+ *   source: '/api/products',
+ *   flags: 'i'
+ * };
+ * ```
+ */
+export declare const SerializedRegexSchema: z.ZodObject<{
+    source: z.ZodString;
+    flags: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SerializedRegex = z.infer<typeof SerializedRegexSchema>;
+//# sourceMappingURL=match-criteria.d.ts.map

package/dist/schemas/match-criteria.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"match-criteria.d.ts","sourceRoot":"","sources":["../../src/schemas/match-criteria.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA2CxB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,qBAAqB;;;iBAWhC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/schemas/match-criteria.js

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+import { isSafePattern } from 'redos-detector';
+/**
+ * Zod schemas for match criteria with regex support.
+ *
+ * **Security:**
+ * - ReDoS protection via redos-detector
+ * - Only safe regex flag characters allowed
+ * - Timeout protection handled separately in domain layer
+ *
+ * **Pattern:**
+ * Serialize regex as { source: string, flags?: string } for JSON compatibility.
+ */
+/**
+ * Valid regex flags (safe subset of JavaScript regex flags).
+ *
+ * Supported flags:
+ * - g: global match
+ * - i: case insensitive
+ * - m: multiline
+ * - s: dotAll (. matches newlines)
+ * - u: unicode
+ * - v: unicode sets
+ * - y: sticky
+ */
+const VALID_REGEX_FLAGS = /^[gimsuvy]*$/;
+/**
+ * Validates that a regex pattern is safe from ReDoS attacks.
+ *
+ * Uses redos-detector to analyze the pattern for exponential backtracking.
+ * Patterns that could cause catastrophic backtracking are rejected.
+ *
+ * @param pattern - The regex pattern to validate
+ * @returns true if the pattern is safe, false otherwise
+ */
+const isPatternSafeFromReDoS = (pattern) => {
+    const result = isSafePattern(pattern);
+    return result.safe;
+};
+/**
+ * Schema for serialized regex patterns.
+ *
+ * **Security Notes:**
+ * - Uses redos-detector to prevent ReDoS attacks
+ * - Validates regex flags to prevent injection
+ * - Source must be non-empty string
+ *
+ * **Serialization:**
+ * Regex patterns are serialized as plain objects to maintain JSON compatibility.
+ * This allows scenarios to be stored in files, databases, or transmitted over network.
+ *
+ * @example
+ * ```typescript
+ * const regex: SerializedRegex = {
+ *   source: '/api/products',
+ *   flags: 'i'
+ * };
+ * ```
+ */
+export const SerializedRegexSchema = z.object({
+    source: z
+        .string()
+        .min(1, 'Regex source must not be empty')
+        .refine(isPatternSafeFromReDoS, {
+        message: 'Regex pattern is unsafe (ReDoS vulnerability detected)',
+    }),
+    flags: z
+        .string()
+        .regex(VALID_REGEX_FLAGS, 'Invalid regex flags (only g, i, m, s, u, v, y allowed)')
+        .optional(),
+});