@scenarist/core 0.4.8 → 0.4.10

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

@@ -1 +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;AAcrE;;;;;;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,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAgB7D,OAAO,CAAC,oBAAoB;IAS5B,OAAO,CAAC,cAAc;IA6CtB,OAAO,CAAC,cAAc;CA8BvB;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,QAAO,YAE7C,CAAC"}
+{"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;AAGrE;;;;;;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,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAgB7D,OAAO,CAAC,oBAAoB;IAS5B,OAAO,CAAC,cAAc;IA6CtB,OAAO,CAAC,cAAc;CA8BvB;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,QAAO,YAE7C,CAAC"}

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

@@ -1,12 +1,4 @@
-const DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
-const isDangerousKey = (key) => DANGEROUS_KEYS.has(key);
-/**
- * Type guard to check if a value is a plain object (Record).
- * Used to properly narrow types after typeof checks.
- */
-const isRecord = (value) => {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-};
+import { isRecord, isDangerousKey } from "../domain/type-guards.js";
 /**
  * In-memory implementation of StateManager port.
  * Fast, single-process state storage for stateful mocks.

package/dist/domain/deep-equals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deep-equals.d.ts","sourceRoot":"","sources":["../../src/domain/deep-equals.ts"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,GAAI,GAAG,OAAO,EAAE,GAAG,OAAO,KAAG,OA+DnD,CAAC"}
+{"version":3,"file":"deep-equals.d.ts","sourceRoot":"","sources":["../../src/domain/deep-equals.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,GAAI,GAAG,OAAO,EAAE,GAAG,OAAO,KAAG,OA+DnD,CAAC"}

package/dist/domain/deep-equals.js

@@ -1,10 +1,4 @@
-/**
- * Type guard to check if a value is a plain object (Record).
- * Used to properly narrow types after typeof checks.
- */
-const isRecord = (value) => {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-};
+import { isRecord } from "./type-guards.js";
 /**
  * Deep equality comparison for values.
  *

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

@@ -1 +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;AAc/D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe,GAC1B,SAAS,kBAAkB,EAC3B,MAAM,MAAM,KACX,OAyBF,CAAC"}
+{"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;AAG/D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe,GAC1B,SAAS,kBAAkB,EAC3B,MAAM,MAAM,KACX,OAyBF,CAAC"}

package/dist/domain/path-extraction.js

@@ -1,12 +1,4 @@
-const DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
-const isDangerousKey = (key) => DANGEROUS_KEYS.has(key);
-/**
- * Type guard to check if a value is a plain object (Record).
- * Used to properly narrow types after typeof checks.
- */
-const isRecord = (value) => {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-};
+import { isRecord, isDangerousKey } from "./type-guards.js";
 /**
  * Extracts a value from HttpRequestContext based on a path expression.
  *

package/dist/domain/regex-matching.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"regex-matching.d.ts","sourceRoot":"","sources":["../../src/domain/regex-matching.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,YAAY,GACvB,OAAO,MAAM,EACb,SAAS,eAAe,KACvB,OASF,CAAC"}
+{"version":3,"file":"regex-matching.d.ts","sourceRoot":"","sources":["../../src/domain/regex-matching.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,YAAY,GACvB,OAAO,MAAM,EACb,SAAS,eAAe,KACvB,OAQF,CAAC"}

package/dist/domain/regex-matching.js

@@ -21,8 +21,7 @@ export const matchesRegex = (value, pattern) => {
         const regex = new RegExp(pattern.source, pattern.flags);
         return regex.test(value);
     }
-    catch (error) {
-        console.error("Regex matching error:", error);
+    catch {
         return false;
     }
 };

package/dist/domain/response-selector.d.ts

@@ -1,7 +1,4 @@
 import type { ResponseSelector, SequenceTracker, StateManager, Logger } from "../ports/index.js";
-/**
- * Options for creating a response selector.
- */
 type CreateResponseSelectorOptions = {
     sequenceTracker?: SequenceTracker;
     stateManager?: StateManager;

package/dist/domain/response-selector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response-selector.d.ts","sourceRoot":"","sources":["../../src/domain/response-selector.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,MAAM,EACP,MAAM,mBAAmB,CAAC;AAuC3B;;GAEG;AACH,KAAK,6BAA6B,GAAG;IACnC,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,GACjC,UAAS,6BAAkC,KAC1C,gBAgRF,CAAC"}
+{"version":3,"file":"response-selector.d.ts","sourceRoot":"","sources":["../../src/domain/response-selector.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,MAAM,EACP,MAAM,mBAAmB,CAAC;AA2C3B,KAAK,6BAA6B,GAAG;IACnC,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAsEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,GACjC,UAAS,6BAAkC,KAC1C,gBAwSF,CAAC"}

package/dist/domain/response-selector.js

@@ -4,20 +4,49 @@ import { applyTemplates } from "./template-replacement.js";
 import { matchesRegex } from "./regex-matching.js";
 import { createStateResponseResolver } from "./state-response-resolver.js";
 import { deepEquals } from "./deep-equals.js";
+import { isRecord } from "./type-guards.js";
 import { noOpLogger } from "../adapters/index.js";
 import { LogCategories, LogEvents } from "./log-events.js";
-/**
- * Type guard to check if a value is a plain object (Record).
- * Used to properly narrow types after typeof checks.
- */
-const isRecord = (value) => {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-};
 const SPECIFICITY_RANGES = {
     MATCH_CRITERIA_BASE: 100,
     SEQUENCE_FALLBACK: 1,
     SIMPLE_FALLBACK: 0,
 };
+const createSequenceExhaustedError = ({ testId, scenarioId, context, }) => new ScenaristError(`Sequence exhausted for ${context.method} ${context.url}. All responses have been consumed and repeat mode is 'none'.`, {
+    code: ErrorCodes.SEQUENCE_EXHAUSTED,
+    context: {
+        testId,
+        scenarioId,
+        requestInfo: {
+            method: context.method,
+            url: context.url,
+        },
+        hint: "Add a fallback mock to handle requests after sequence exhaustion, or use repeat: 'last' or 'cycle' instead of 'none'.",
+    },
+});
+const createNoMockFoundError = ({ testId, scenarioId, context, }) => new ScenaristError(`No mock matched for ${context.method} ${context.url}`, {
+    code: ErrorCodes.NO_MOCK_FOUND,
+    context: {
+        testId,
+        scenarioId,
+        requestInfo: {
+            method: context.method,
+            url: context.url,
+        },
+        hint: "Add a fallback mock (without match criteria) to handle unmatched requests, or add a mock with matching criteria.",
+    },
+});
+const createNoResponseTypeError = ({ testId, scenarioId, mockIndex, }) => new ScenaristError(`Mock has neither response nor sequence field`, {
+    code: ErrorCodes.VALIDATION_ERROR,
+    context: {
+        testId,
+        scenarioId,
+        mockInfo: {
+            index: mockIndex,
+        },
+        hint: "Each mock must have a 'response', 'sequence', or 'stateResponse' field.",
+    },
+});
 /**
  * Creates a response selector domain service.
  *
@@ -31,159 +60,154 @@ const SPECIFICITY_RANGES = {
  */
 export const createResponseSelector = (options = {}) => {
     const { sequenceTracker, stateManager, logger = noOpLogger } = options;
-    return {
-        selectResponse(testId, scenarioId, context, mocks) {
-            const logContext = { testId, scenarioId };
-            // Log the number of candidate mocks
-            logger.debug(LogCategories.MATCHING, LogEvents.MOCK_CANDIDATES_FOUND, logContext, {
-                count: mocks.length,
-            });
-            let bestMatch = null;
-            // Track if we skipped any exhausted sequences (for better error messages)
-            let skippedExhaustedSequences = false;
-            // Find all matching mocks and score them by specificity
-            for (let mockIndex = 0; mockIndex < mocks.length; mockIndex++) {
-                // eslint-disable-next-line security/detect-object-injection -- Index bounded by loop (0 <= i < length)
-                const mockWithParams = mocks[mockIndex];
-                const mock = mockWithParams.mock;
-                // Skip exhausted sequences (repeat: 'none' that have been exhausted)
-                if (mock.sequence && sequenceTracker) {
-                    const { exhausted } = sequenceTracker.getPosition(testId, scenarioId, mockIndex);
-                    if (exhausted) {
-                        skippedExhaustedSequences = true;
-                        continue; // Skip to next mock, allowing fallback to be selected
-                    }
-                }
-                // Check if this mock has match criteria
-                if (mock.match) {
-                    // If match criteria exists, check if it matches the request
-                    const matched = matchesCriteria(context, mock.match, testId, stateManager);
-                    // Log the evaluation result
-                    logger.debug(LogCategories.MATCHING, LogEvents.MOCK_MATCH_EVALUATED, logContext, {
-                        mockIndex,
-                        matched,
-                        hasCriteria: true,
-                    });
-                    if (matched) {
-                        // Match criteria always have higher priority than fallbacks
-                        // Base specificity ensures even 1 field beats any fallback
-                        const specificity = SPECIFICITY_RANGES.MATCH_CRITERIA_BASE +
-                            calculateSpecificity(mock.match);
-                        // Keep this mock if it's more specific than current best
-                        // (or if no best match yet)
-                        if (!bestMatch || specificity > bestMatch.specificity) {
-                            bestMatch = { mockWithParams, mockIndex, specificity };
-                        }
-                    }
-                    // If match criteria exists but doesn't match, skip to next mock
-                    continue;
-                }
-                // No match criteria = fallback mock (always matches)
-                // Log fallback evaluation with response type info for debugging Issue #328
-                logger.debug(LogCategories.MATCHING, LogEvents.MOCK_MATCH_EVALUATED, logContext, {
+    const isExhaustedSequence = ({ testId, scenarioId, mockIndex, mock, }) => {
+        if (!mock.sequence || !sequenceTracker) {
+            return false;
+        }
+        return sequenceTracker.getPosition(testId, scenarioId, mockIndex).exhausted;
+    };
+    const scoreCriteriaMatch = ({ context, criteria, mockIndex, logContext, }) => {
+        const matched = matchesCriteria({
+            context,
+            criteria,
+            testId: logContext.testId,
+            stateManager,
+        });
+        logger.debug(LogCategories.MATCHING, LogEvents.MOCK_MATCH_EVALUATED, logContext, { mockIndex, matched, hasCriteria: true });
+        if (!matched) {
+            return null;
+        }
+        return (SPECIFICITY_RANGES.MATCH_CRITERIA_BASE + calculateSpecificity(criteria));
+    };
+    const scoreFallback = ({ mock, mockIndex, logContext, }) => {
+        logger.debug(LogCategories.MATCHING, LogEvents.MOCK_MATCH_EVALUATED, logContext, {
+            mockIndex,
+            matched: true,
+            hasCriteria: false,
+            hasSequence: !!mock.sequence,
+            hasStateResponse: !!mock.stateResponse,
+            hasResponse: !!mock.response,
+        });
+        return mock.sequence || mock.stateResponse
+            ? SPECIFICITY_RANGES.SEQUENCE_FALLBACK
+            : SPECIFICITY_RANGES.SIMPLE_FALLBACK;
+    };
+    const findBestMatch = ({ testId, scenarioId, context, mocks, }) => {
+        const logContext = { testId, scenarioId };
+        return mocks.reduce((acc, mockWithParams, mockIndex) => {
+            const mock = mockWithParams.mock;
+            if (isExhaustedSequence({ testId, scenarioId, mockIndex, mock })) {
+                return { ...acc, skippedExhaustedSequences: true };
+            }
+            if (mock.match) {
+                const specificity = scoreCriteriaMatch({
+                    context,
+                    criteria: mock.match,
                     mockIndex,
-                    matched: true,
-                    hasCriteria: false,
-                    hasSequence: !!mock.sequence,
-                    hasStateResponse: !!mock.stateResponse,
-                    hasResponse: !!mock.response,
+                    logContext,
                 });
-                // Dynamic response types (sequence, stateResponse) get higher priority than simple responses
-                // This ensures they are selected over simple fallback responses
-                // Both sequence and stateResponse get the same specificity (Issue #316 fix)
-                const fallbackSpecificity = mock.sequence || mock.stateResponse
-                    ? SPECIFICITY_RANGES.SEQUENCE_FALLBACK
-                    : SPECIFICITY_RANGES.SIMPLE_FALLBACK;
-                if (!bestMatch || fallbackSpecificity >= bestMatch.specificity) {
-                    // For equal specificity fallbacks, last wins
-                    // This allows active scenario mocks to override default mocks
-                    // Applies to both simple fallbacks (0) and sequence fallbacks (1)
-                    bestMatch = {
-                        mockWithParams,
-                        mockIndex,
-                        specificity: fallbackSpecificity,
+                if (specificity !== null &&
+                    (!acc.bestMatch || specificity > acc.bestMatch.specificity)) {
+                    return {
+                        ...acc,
+                        bestMatch: { mockWithParams, mockIndex, specificity },
                     };
                 }
+                return acc;
+            }
+            const specificity = scoreFallback({ mock, mockIndex, logContext });
+            if (!acc.bestMatch || specificity >= acc.bestMatch.specificity) {
+                return {
+                    ...acc,
+                    bestMatch: { mockWithParams, mockIndex, specificity },
+                };
             }
-            // Return the best matching mock
+            return acc;
+        }, { bestMatch: null, skippedExhaustedSequences: false });
+    };
+    const applyResponseTemplates = ({ testId, response, params, }) => {
+        if (!stateManager && !params) {
+            return response;
+        }
+        const templateData = {
+            state: stateManager ? stateManager.getAll(testId) : {},
+            params: params || {},
+        };
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- applyTemplates preserves structure; input ScenaristResponse → output ScenaristResponse
+        return applyTemplates(response, templateData);
+    };
+    const applyAfterResponseState = ({ testId, mock, responseResult, logContext, }) => {
+        const effectiveAfterResponse = resolveEffectiveAfterResponse(mock.afterResponse, responseResult.matchedCondition);
+        if (effectiveAfterResponse?.setState && stateManager) {
+            stateManager.merge(testId, effectiveAfterResponse.setState);
+            logger.debug(LogCategories.STATE, LogEvents.STATE_SET, logContext, {
+                setState: effectiveAfterResponse.setState,
+                source: responseResult.matchedCondition ? "condition" : "mock-level",
+            });
+        }
+    };
+    const processMatchedMock = ({ testId, scenarioId, context, match, }) => {
+        const logContext = { testId, scenarioId };
+        const { mockWithParams, mockIndex, specificity } = match;
+        const mock = mockWithParams.mock;
+        logger.info(LogCategories.MATCHING, LogEvents.MOCK_SELECTED, logContext, {
+            mockIndex,
+            specificity,
+        });
+        const responseResult = selectResponseFromMock({
+            testId,
+            scenarioId,
+            mockIndex,
+            mock,
+            sequenceTracker,
+            stateManager,
+            logger,
+        });
+        if (!responseResult) {
+            return {
+                success: false,
+                error: createNoResponseTypeError({ testId, scenarioId, mockIndex }),
+            };
+        }
+        if (mock.captureState && stateManager) {
+            captureState({
+                testId,
+                context,
+                captureConfig: mock.captureState,
+                stateManager,
+            });
+        }
+        const finalResponse = applyResponseTemplates({
+            testId,
+            response: responseResult.response,
+            params: mockWithParams.params,
+        });
+        applyAfterResponseState({ testId, mock, responseResult, logContext });
+        return { success: true, data: finalResponse };
+    };
+    return {
+        selectResponse(testId, scenarioId, context, mocks) {
+            const logContext = { testId, scenarioId };
+            logger.debug(LogCategories.MATCHING, LogEvents.MOCK_CANDIDATES_FOUND, logContext, { count: mocks.length });
+            const { bestMatch, skippedExhaustedSequences } = findBestMatch({
+                testId,
+                scenarioId,
+                context,
+                mocks,
+            });
             if (bestMatch) {
-                const { mockWithParams, mockIndex, specificity } = bestMatch;
-                const mock = mockWithParams.mock;
-                // Log successful selection
-                logger.info(LogCategories.MATCHING, LogEvents.MOCK_SELECTED, logContext, {
-                    mockIndex,
-                    specificity,
+                return processMatchedMock({
+                    testId,
+                    scenarioId,
+                    context,
+                    match: bestMatch,
                 });
-                // Select response (single, sequence, or stateResponse)
-                const responseResult = selectResponseFromMock(testId, scenarioId, mockIndex, mock, sequenceTracker, stateManager, logger);
-                if (!responseResult) {
-                    return {
-                        success: false,
-                        error: new ScenaristError(`Mock has neither response nor sequence field`, {
-                            code: ErrorCodes.VALIDATION_ERROR,
-                            context: {
-                                testId,
-                                scenarioId,
-                                mockInfo: {
-                                    index: mockIndex,
-                                },
-                                hint: "Each mock must have a 'response', 'sequence', or 'stateResponse' field.",
-                            },
-                        }),
-                    };
-                }
-                // Phase 3: Capture state from request if configured
-                if (mock.captureState && stateManager) {
-                    captureState(testId, context, mock.captureState, stateManager);
-                }
-                // Apply templates to response (both state AND params)
-                let finalResponse = responseResult.response;
-                if (stateManager || mockWithParams.params) {
-                    const currentState = stateManager ? stateManager.getAll(testId) : {};
-                    // Merge state and params for template replacement
-                    // params take precedence over state for the same key
-                    const templateData = {
-                        state: currentState,
-                        params: mockWithParams.params || {},
-                    };
-                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- applyTemplates preserves structure; input ScenaristResponse → output ScenaristResponse
-                    finalResponse = applyTemplates(responseResult.response, templateData);
-                }
-                // Apply afterResponse.setState to mutate state for subsequent requests
-                // Uses condition-level afterResponse if available (#338)
-                const effectiveAfterResponse = resolveEffectiveAfterResponse(mock.afterResponse, responseResult.matchedCondition);
-                if (effectiveAfterResponse?.setState && stateManager) {
-                    stateManager.merge(testId, effectiveAfterResponse.setState);
-                    logger.debug(LogCategories.STATE, LogEvents.STATE_SET, logContext, {
-                        setState: effectiveAfterResponse.setState,
-                        source: responseResult.matchedCondition
-                            ? "condition"
-                            : "mock-level",
-                    });
-                }
-                return { success: true, data: finalResponse };
             }
-            // No mock matched - determine specific error type
             if (skippedExhaustedSequences) {
-                // All matching mocks were exhausted sequences
-                logger.warn(LogCategories.SEQUENCE, LogEvents.SEQUENCE_EXHAUSTED, logContext, {
-                    url: context.url,
-                    method: context.method,
-                });
+                logger.warn(LogCategories.SEQUENCE, LogEvents.SEQUENCE_EXHAUSTED, logContext, { url: context.url, method: context.method });
                 return {
                     success: false,
-                    error: new ScenaristError(`Sequence exhausted for ${context.method} ${context.url}. All responses have been consumed and repeat mode is 'none'.`, {
-                        code: ErrorCodes.SEQUENCE_EXHAUSTED,
-                        context: {
-                            testId,
-                            scenarioId,
-                            requestInfo: {
-                                method: context.method,
-                                url: context.url,
-                            },
-                            hint: "Add a fallback mock to handle requests after sequence exhaustion, or use repeat: 'last' or 'cycle' instead of 'none'.",
-                        },
-                    }),
+                    error: createSequenceExhaustedError({ testId, scenarioId, context }),
                 };
             }
             logger.warn(LogCategories.MATCHING, LogEvents.MOCK_NO_MATCH, logContext, {
@@ -193,18 +217,7 @@ export const createResponseSelector = (options = {}) => {
             });
             return {
                 success: false,
-                error: new ScenaristError(`No mock matched for ${context.method} ${context.url}`, {
-                    code: ErrorCodes.NO_MOCK_FOUND,
-                    context: {
-                        testId,
-                        scenarioId,
-                        requestInfo: {
-                            method: context.method,
-                            url: context.url,
-                        },
-                        hint: "Add a fallback mock (without match criteria) to handle unmatched requests, or add a mock with matching criteria.",
-                    },
-                }),
+                error: createNoMockFoundError({ testId, scenarioId, context }),
             };
         },
     };
@@ -240,40 +253,34 @@ const resolveEffectiveAfterResponse = (mockAfterResponse, matchedCondition) => {
  * @param logger - Logger for debugging
  * @returns MockResponseResult or null if mock has no response type
  */
-const selectResponseFromMock = (testId, scenarioId, mockIndex, mock, sequenceTracker, stateManager, logger) => {
+const selectResponseFromMock = ({ testId, scenarioId, mockIndex, mock, sequenceTracker, stateManager, logger, }) => {
     const logContext = { testId, scenarioId };
-    // Phase 2: If mock has a sequence, use sequence tracker
     if (mock.sequence) {
         if (!sequenceTracker) {
-            // Sequence defined but no tracker provided - return first response
-            // Note: Schema validation ensures responses array has at least 1 element,
-            // but defensive check handles malformed data that bypasses validation
             const firstResponse = mock.sequence.responses[0];
             return firstResponse
                 ? { response: firstResponse, matchedCondition: null }
                 : null;
         }
-        // Get current position from tracker
         const { position } = sequenceTracker.getPosition(testId, scenarioId, mockIndex);
-        // Get response at current position
-        // Note: Exhausted sequences are skipped during matching phase,
-        // so position should always be valid here
         // eslint-disable-next-line security/detect-object-injection -- Position bounded by sequence tracker
         const response = mock.sequence.responses[position];
-        // Advance position for next call
         const repeatMode = mock.sequence.repeat || "last";
         sequenceTracker.advance(testId, scenarioId, mockIndex, mock.sequence.responses.length, repeatMode);
         return { response, matchedCondition: null };
     }
-    // State-aware response: evaluate conditions against current state
     if (mock.stateResponse) {
-        return resolveStateResponse(testId, mock.stateResponse, stateManager, logger, logContext);
+        return resolveStateResponse({
+            testId,
+            stateResponse: mock.stateResponse,
+            stateManager,
+            logger,
+            logContext,
+        });
     }
-    // Phase 1: Single response
     if (mock.response) {
         return { response: mock.response, matchedCondition: null };
     }
-    // No response type defined
     return null;
 };
 /**
@@ -289,8 +296,7 @@ const selectResponseFromMock = (testId, scenarioId, mockIndex, mock, sequenceTra
  * @param logContext - Context for log messages
  * @returns MockResponseResult with response and matched condition
  */
-const resolveStateResponse = (testId, stateResponse, stateManager, logger, logContext) => {
-    // Without stateManager, always return default
+const resolveStateResponse = ({ testId, stateResponse, stateManager, logger, logContext, }) => {
     if (!stateManager) {
         logger.debug(LogCategories.STATE, LogEvents.STATE_RESPONSE_RESOLVED, logContext, {
             result: "default",
@@ -356,38 +362,23 @@ const calculateSpecificity = (criteria) => {
  * @param testId - Test ID for state isolation
  * @param stateManager - Optional state manager for state-based matching
  */
-const matchesCriteria = (context, criteria, testId, stateManager) => {
-    // Check URL match (exact match or pattern)
-    if (criteria.url) {
-        if (!matchesValue(context.url, criteria.url)) {
-            return false;
-        }
+const matchesCriteria = ({ context, criteria, testId, stateManager, }) => {
+    if (criteria.url && !matchesValue(context.url, criteria.url)) {
+        return false;
     }
-    // Check body match (partial match)
-    if (criteria.body) {
-        if (!matchesBody(context.body, criteria.body)) {
-            return false;
-        }
+    if (criteria.body && !matchesBody(context.body, criteria.body)) {
+        return false;
     }
-    // Check headers match (exact match on specified headers)
-    if (criteria.headers) {
-        if (!matchesHeaders(context.headers, criteria.headers)) {
-            return false;
-        }
+    if (criteria.headers && !matchesHeaders(context.headers, criteria.headers)) {
+        return false;
     }
-    // Check query match (exact match on specified query params)
-    if (criteria.query) {
-        if (!matchesQuery(context.query, criteria.query)) {
-            return false;
-        }
+    if (criteria.query && !matchesQuery(context.query, criteria.query)) {
+        return false;
     }
-    // Check state match (partial match on current test state)
-    if (criteria.state) {
-        if (!matchesState(criteria.state, testId, stateManager)) {
-            return false;
-        }
+    if (criteria.state &&
+        !matchesState({ stateCriteria: criteria.state, testId, stateManager })) {
+        return false;
     }
-    // All criteria matched
     return true;
 };
 /**
@@ -399,18 +390,15 @@ const matchesCriteria = (context, criteria, testId, stateManager) => {
  * @param stateManager - State manager to retrieve current state
  * @returns true if all criteria keys match, false otherwise
  */
-const matchesState = (stateCriteria, testId, stateManager) => {
-    // Without stateManager, state matching always fails
+const matchesState = ({ stateCriteria, testId, stateManager, }) => {
     if (!stateManager) {
         return false;
     }
     const currentState = stateManager.getAll(testId);
-    // All keys in criteria must exist in state with equal values
     for (const [key, expectedValue] of Object.entries(stateCriteria)) {
         if (!(key in currentState)) {
             return false;
         }
-        // Deep equality check for values (handles primitives, null, objects)
         // eslint-disable-next-line security/detect-object-injection -- Key from Object.entries iteration
         if (!deepEquals(currentState[key], expectedValue)) {
             return false;
@@ -554,10 +542,9 @@ const matchesQuery = (requestQuery, criteriaQuery) => {
  * @param captureConfig - Capture configuration (state key -> path expression)
  * @param stateManager - State manager to store captured values
  */
-const captureState = (testId, context, captureConfig, stateManager) => {
+const captureState = ({ testId, context, captureConfig, stateManager, }) => {
     for (const [stateKey, pathExpression] of Object.entries(captureConfig)) {
         const value = extractFromPath(context, pathExpression);
-        // Guard: Only capture if value exists
         if (value === undefined) {
             continue;
         }

package/dist/domain/scenario-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scenario-manager.d.ts","sourceRoot":"","sources":["../../src/domain/scenario-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,YAAY,EACZ,MAAM,EACP,MAAM,mBAAmB,CAAC;AAwC3B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,GAAI,6DAMnC;IACD,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,KAAK,EAAE,aAAa,CAAC;IACrB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,KAAG,eAmIH,CAAC"}
+{"version":3,"file":"scenario-manager.d.ts","sourceRoot":"","sources":["../../src/domain/scenario-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,YAAY,EACZ,MAAM,EACP,MAAM,mBAAmB,CAAC;AAwD3B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,GAAI,6DAMnC;IACD,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,KAAK,EAAE,aAAa,CAAC;IACrB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,KAAG,eAyHH,CAAC"}

package/dist/domain/scenario-manager.js

@@ -20,6 +20,14 @@ const createScenarioValidationError = (scenarioId, validationErrors) => {
         },
     });
 };
+const createScenarioNotFoundError = (scenarioId, testId) => new ScenaristError(`Scenario '${scenarioId}' not found. Did you forget to register it?`, {
+    code: ErrorCodes.SCENARIO_NOT_FOUND,
+    context: {
+        testId,
+        scenarioId,
+        hint: "Make sure to register the scenario before switching to it. Use manager.registerScenario(definition) first.",
+    },
+});
 /**
  * Factory function to create a ScenarioManager implementation.
  *
@@ -72,14 +80,7 @@ export const createScenarioManager = ({ registry, store, stateManager, sequenceT
                 });
                 return {
                     success: false,
-                    error: new ScenaristError(`Scenario '${scenarioId}' not found. Did you forget to register it?`, {
-                        code: ErrorCodes.SCENARIO_NOT_FOUND,
-                        context: {
-                            testId,
-                            scenarioId,
-                            hint: "Make sure to register the scenario before switching to it. Use manager.registerScenario(definition) first.",
-                        },
-                    }),
+                    error: createScenarioNotFoundError(scenarioId, testId),
                 };
             }
             const activeScenario = {

package/dist/domain/template-replacement.d.ts

@@ -1,15 +1,2 @@
-/**
- * Applies templates to a value.
- * Replaces {{state.key}} and {{params.key}} patterns with actual values.
- *
- * Note: This function preserves the structure of the input value.
- * Callers passing typed objects (like ScenaristResponse) can safely
- * cast the return value back to the input type.
- *
- * @param value - Value to apply templates to (string, object, array, or primitive)
- * @param templateData - Object containing state and params for template replacement.
- *                       Can be flat object (backward compatible) or { state: {...}, params: {...} }
- * @returns Value with templates replaced
- */
 export declare const applyTemplates: (value: unknown, templateData: Record<string, unknown>) => unknown;
 //# sourceMappingURL=template-replacement.d.ts.map

package/dist/domain/template-replacement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template-replacement.d.ts","sourceRoot":"","sources":["../../src/domain/template-replacement.ts"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc,GACzB,OAAO,OAAO,EACd,cAAc,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KACpC,OA+DF,CAAC"}
+{"version":3,"file":"template-replacement.d.ts","sourceRoot":"","sources":["../../src/domain/template-replacement.ts"],"names":[],"mappings":"AAqDA,eAAO,MAAM,cAAc,GACzB,OAAO,OAAO,EACd,cAAc,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KACpC,OAqBF,CAAC"}

package/dist/domain/template-replacement.js

@@ -1,17 +1,4 @@
-/**
- * Type guard to check if a value is a plain object (Record).
- * Used to properly narrow types after typeof checks.
- */
-const isRecord = (value) => {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-};
-/**
- * Security: Check if a property key could cause prototype pollution.
- * @see https://github.com/citypaul/scenarist/security/code-scanning
- */
-const isDangerousKey = (key) => {
-    return key === "__proto__" || key === "constructor" || key === "prototype";
-};
+import { isRecord, isDangerousKey } from "./type-guards.js";
 /**
  * Applies templates to a value.
  * Replaces {{state.key}} and {{params.key}} patterns with actual values.
@@ -25,45 +12,35 @@ const isDangerousKey = (key) => {
  *                       Can be flat object (backward compatible) or { state: {...}, params: {...} }
  * @returns Value with templates replaced
  */
+const PURE_TEMPLATE_PATTERN = /^\{\{(state|params)\.([^}]{1,256})\}\}$/;
+const MIXED_TEMPLATE_PATTERN = /\{\{(state|params)\.([^}]{1,256})\}\}/g;
+const applyTemplatesToString = (value, templateData) => {
+    const pureTemplateMatch = PURE_TEMPLATE_PATTERN.exec(value);
+    if (pureTemplateMatch) {
+        const prefix = pureTemplateMatch[1];
+        const path = pureTemplateMatch[2];
+        const resolvedValue = resolveTemplatePath(templateData, prefix, path);
+        return resolvedValue !== undefined ? resolvedValue : null;
+    }
+    return value.replace(MIXED_TEMPLATE_PATTERN, (match, prefix, path) => {
+        const resolvedValue = resolveTemplatePath(templateData, prefix, path);
+        if (resolvedValue === undefined) {
+            return match;
+        }
+        return String(resolvedValue);
+    });
+};
+const normalizeTemplateData = (templateData) => templateData.state !== undefined || templateData.params !== undefined
+    ? templateData
+    : { state: templateData, params: {} };
 export const applyTemplates = (value, templateData) => {
-    // Backward compatibility: If templateData doesn't have 'state' or 'params' keys,
-    // treat it as a flat state object and wrap it
-    const normalizedData = templateData.state !== undefined || templateData.params !== undefined
-        ? templateData
-        : { state: templateData, params: {} };
-    // Guard: Handle strings (base case)
+    const normalizedData = normalizeTemplateData(templateData);
     if (typeof value === "string") {
-        // Check if entire string is a single pure template (no surrounding text)
-        // Supports both {{state.key}} and {{params.key}}
-        // Using {1,256} limit to prevent ReDoS attacks with malicious input
-        const pureTemplateMatch = /^\{\{(state|params)\.([^}]{1,256})\}\}$/.exec(value);
-        if (pureTemplateMatch) {
-            // Pure template: return raw value (preserves type - arrays, numbers, objects)
-            const prefix = pureTemplateMatch[1]; // 'state' or 'params'
-            const path = pureTemplateMatch[2]; // Guaranteed to exist by regex capture group
-            const resolvedValue = resolveTemplatePath(normalizedData, prefix, path);
-            // Return raw value if found, otherwise return null (JSON-safe)
-            // null is used instead of undefined to ensure JSON serialization preserves the field
-            return resolvedValue !== undefined ? resolvedValue : null;
-        }
-        // Mixed template (has surrounding text): use string replacement
-        // Supports both {{state.key}} and {{params.key}}
-        // Using {1,256} limit to prevent ReDoS attacks with malicious input
-        return value.replace(/\{\{(state|params)\.([^}]{1,256})\}\}/g, (match, prefix, path) => {
-            const resolvedValue = resolveTemplatePath(normalizedData, prefix, path);
-            // Guard: Missing keys remain as template
-            if (resolvedValue === undefined) {
-                return match;
-            }
-            // Convert to string for concatenation with surrounding text
-            return String(resolvedValue);
-        });
+        return applyTemplatesToString(value, normalizedData);
     }
-    // Guard: Handle arrays recursively
     if (Array.isArray(value)) {
         return value.map((item) => applyTemplates(item, normalizedData));
     }
-    // Guard: Handle objects recursively
     if (typeof value === "object" && value !== null) {
         const result = {};
         for (const [key, val] of Object.entries(value)) {
@@ -72,7 +49,6 @@ export const applyTemplates = (value, templateData) => {
         }
         return result;
     }
-    // Primitives (number, boolean, null) returned unchanged
     return value;
 };
 /**

package/dist/domain/type-guards.d.ts

@@ -0,0 +1,3 @@
+export declare const isDangerousKey: (key: string) => boolean;
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+//# sourceMappingURL=type-guards.d.ts.map

package/dist/domain/type-guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-guards.d.ts","sourceRoot":"","sources":["../../src/domain/type-guards.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc,GAAI,KAAK,MAAM,KAAG,OAAkC,CAAC;AAEhF,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CACH,CAAC"}

package/dist/domain/type-guards.js

@@ -0,0 +1,3 @@
+const DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+export const isDangerousKey = (key) => DANGEROUS_KEYS.has(key);
+export const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scenarist/core",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "description": "Internal: Hexagonal architecture core for scenario-based testing with MSW",
   "author": "Paul Hammond (citypaul) <paul@packsoftware.co.uk>",
   "license": "MIT",
@@ -46,13 +46,13 @@
     "LICENSE"
   ],
   "dependencies": {
-    "redos-detector": "^6.1.2",
+    "redos-detector": "^6.1.4",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.0.18",
     "@vitest/ui": "^4.0.18",
-    "eslint": "^9.39.2",
+    "eslint": "^9.39.3",
     "fast-check": "^4.5.3",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18",