@scenarist/core 0.3.3 → 0.4.1

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

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

package/dist/domain/config-builder.js

@@ -23,6 +23,7 @@ export const buildConfig = (input) => {
         endpoints: {
             setScenario: input.endpoints?.setScenario ?? "/__scenario__",
             getScenario: input.endpoints?.getScenario ?? "/__scenario__",
+            getState: input.endpoints?.getState ?? "/__scenarist__/state",
         },
         defaultTestId: input.defaultTestId ?? "default-test",
         errorBehaviors: {

package/dist/domain/index.d.ts

@@ -3,7 +3,7 @@ export { buildConfig } from "./config-builder.js";
 export { createResponseSelector } from "./response-selector.js";
 export { matchesRegex } from "./regex-matching.js";
 export { createStateConditionEvaluator, type StateConditionEvaluator, } from "./state-condition-evaluator.js";
-export { createStateResponseResolver, type StateResponseResolver, } from "./state-response-resolver.js";
+export { createStateResponseResolver, type StateResponseResolver, type StateResponseResult, } from "./state-response-resolver.js";
 export { deepEquals } from "./deep-equals.js";
 export { LogCategories, LogEvents, type LogEvent } from "./log-events.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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;AACnD,OAAO,EACL,6BAA6B,EAC7B,KAAK,uBAAuB,GAC7B,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,2BAA2B,EAC3B,KAAK,qBAAqB,GAC3B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC"}
+{"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;AACnD,OAAO,EACL,6BAA6B,EAC7B,KAAK,uBAAuB,GAC7B,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,2BAA2B,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,GACzB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC"}

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;AAyB3B;;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,gBAwQF,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;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"}

package/dist/domain/response-selector.js

@@ -115,8 +115,8 @@ export const createResponseSelector = (options = {}) => {
                     specificity,
                 });
                 // Select response (single, sequence, or stateResponse)
-                const response = selectResponseFromMock(testId, scenarioId, mockIndex, mock, sequenceTracker, stateManager, logger);
-                if (!response) {
+                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`, {
@@ -137,7 +137,7 @@ export const createResponseSelector = (options = {}) => {
                     captureState(testId, context, mock.captureState, stateManager);
                 }
                 // Apply templates to response (both state AND params)
-                let finalResponse = response;
+                let finalResponse = responseResult.response;
                 if (stateManager || mockWithParams.params) {
                     const currentState = stateManager ? stateManager.getAll(testId) : {};
                     // Merge state and params for template replacement
@@ -147,13 +147,18 @@ export const createResponseSelector = (options = {}) => {
                         params: mockWithParams.params || {},
                     };
                     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- applyTemplates preserves structure; input ScenaristResponse → output ScenaristResponse
-                    finalResponse = applyTemplates(response, templateData);
+                    finalResponse = applyTemplates(responseResult.response, templateData);
                 }
                 // Apply afterResponse.setState to mutate state for subsequent requests
-                if (mock.afterResponse?.setState && stateManager) {
-                    stateManager.merge(testId, mock.afterResponse.setState);
+                // 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: mock.afterResponse.setState,
+                        setState: effectiveAfterResponse.setState,
+                        source: responseResult.matchedCondition
+                            ? "condition"
+                            : "mock-level",
                     });
                 }
                 return { success: true, data: finalResponse };
@@ -204,6 +209,25 @@ export const createResponseSelector = (options = {}) => {
         },
     };
 };
+/**
+ * Determine which afterResponse to apply.
+ *
+ * Resolution order (per #338):
+ * 1. If condition matched AND has 'afterResponse' key → use condition's (including null)
+ * 2. Otherwise → use mock-level afterResponse
+ *
+ * @param mockAfterResponse - Mock-level afterResponse (fallback)
+ * @param matchedCondition - The matched condition from stateResponse (or null)
+ * @returns The effective afterResponse to apply (or null/undefined for no mutation)
+ */
+const resolveEffectiveAfterResponse = (mockAfterResponse, matchedCondition) => {
+    // If a condition matched and has its own afterResponse key, use it (including null)
+    if (matchedCondition && "afterResponse" in matchedCondition) {
+        return matchedCondition.afterResponse;
+    }
+    // Otherwise, fall back to mock-level afterResponse
+    return mockAfterResponse;
+};
 /**
  * Select a response from a mock (single response, sequence, or stateResponse).
  *
@@ -214,7 +238,7 @@ export const createResponseSelector = (options = {}) => {
  * @param sequenceTracker - Optional sequence tracker for Phase 2
  * @param stateManager - Optional state manager for stateResponse
  * @param logger - Logger for debugging
- * @returns ScenaristResponse or null if mock has no response type
+ * @returns MockResponseResult or null if mock has no response type
  */
 const selectResponseFromMock = (testId, scenarioId, mockIndex, mock, sequenceTracker, stateManager, logger) => {
     const logContext = { testId, scenarioId };
@@ -222,7 +246,12 @@ const selectResponseFromMock = (testId, scenarioId, mockIndex, mock, sequenceTra
     if (mock.sequence) {
         if (!sequenceTracker) {
             // Sequence defined but no tracker provided - return first response
-            return mock.sequence.responses[0] || null;
+            // 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);
@@ -234,7 +263,7 @@ const selectResponseFromMock = (testId, scenarioId, mockIndex, mock, sequenceTra
         // Advance position for next call
         const repeatMode = mock.sequence.repeat || "last";
         sequenceTracker.advance(testId, scenarioId, mockIndex, mock.sequence.responses.length, repeatMode);
-        return response;
+        return { response, matchedCondition: null };
     }
     // State-aware response: evaluate conditions against current state
     if (mock.stateResponse) {
@@ -242,13 +271,13 @@ const selectResponseFromMock = (testId, scenarioId, mockIndex, mock, sequenceTra
     }
     // Phase 1: Single response
     if (mock.response) {
-        return mock.response;
+        return { response: mock.response, matchedCondition: null };
     }
     // No response type defined
     return null;
 };
 /**
- * Resolve a stateResponse configuration to a single response.
+ * Resolve a stateResponse configuration to a response and matched condition.
  *
  * Uses the StateResponseResolver to evaluate conditions against
  * current test state and return the appropriate response.
@@ -258,7 +287,7 @@ const selectResponseFromMock = (testId, scenarioId, mockIndex, mock, sequenceTra
  * @param stateManager - Optional state manager for state lookup
  * @param logger - Logger for debugging
  * @param logContext - Context for log messages
- * @returns The resolved response (matching condition or default)
+ * @returns MockResponseResult with response and matched condition
  */
 const resolveStateResponse = (testId, stateResponse, stateManager, logger, logContext) => {
     // Without stateManager, always return default
@@ -267,25 +296,20 @@ const resolveStateResponse = (testId, stateResponse, stateManager, logger, logCo
             result: "default",
             reason: "no_state_manager",
         });
-        return stateResponse.default;
+        return { response: stateResponse.default, matchedCondition: null };
     }
     // Get current state for this test
     const currentState = stateManager.getAll(testId);
-    // Create resolver and evaluate conditions
+    // Create resolver and evaluate conditions with matched condition tracking
     const resolver = createStateResponseResolver();
-    const response = resolver.resolveResponse(stateResponse, currentState);
-    // Log which response was selected and why
-    const isDefault = response === stateResponse.default;
-    const matchedCondition = isDefault
-        ? null
-        : stateResponse.conditions.find((c) => resolver.resolveResponse({ default: stateResponse.default, conditions: [c] }, currentState) !== stateResponse.default);
+    const result = resolver.resolveResponseWithCondition(stateResponse, currentState);
     logger.debug(LogCategories.STATE, LogEvents.STATE_RESPONSE_RESOLVED, logContext, {
-        result: isDefault ? "default" : "condition",
+        result: result.matchedCondition ? "condition" : "default",
         currentState,
         conditionsCount: stateResponse.conditions.length,
-        matchedWhen: matchedCondition?.when ?? null,
+        matchedWhen: result.matchedCondition?.when ?? null,
     });
-    return response;
+    return result;
 };
 /**
  * Calculate specificity score for match criteria.

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,eA+HH,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;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"}

package/dist/domain/scenario-manager.js

@@ -110,5 +110,8 @@ export const createScenarioManager = ({ registry, store, stateManager, sequenceT
         getScenarioById(id) {
             return registry.get(id);
         },
+        getState(testId) {
+            return stateManager?.getAll(testId) ?? {};
+        },
     };
 };

package/dist/domain/state-response-resolver.d.ts

@@ -1,6 +1,16 @@
-import type { StatefulMockResponse } from "../schemas/state-aware-mocking.js";
+import type { StatefulMockResponse, StateCondition } from "../schemas/state-aware-mocking.js";
 import type { ScenaristResponse } from "../schemas/scenario-definition.js";
 import type { StateConditionEvaluator } from "./state-condition-evaluator.js";
+/**
+ * Result of resolving a stateResponse configuration.
+ *
+ * Contains both the resolved response and the matched condition (if any).
+ * This enables callers to determine which afterResponse to apply.
+ */
+export type StateResponseResult = {
+    readonly response: ScenaristResponse;
+    readonly matchedCondition: StateCondition | null;
+};
 /**
  * StateResponseResolver port for resolving stateResponse configurations.
  *
@@ -15,8 +25,20 @@ export type StateResponseResolver = {
      * @param stateResponse - The stateResponse configuration
      * @param currentState - Current test state
      * @returns The resolved response (matching condition or default)
+     * @deprecated Use resolveResponseWithCondition for condition-level afterResponse support
      */
     resolveResponse(stateResponse: StatefulMockResponse, currentState: Readonly<Record<string, unknown>>): ScenaristResponse;
+    /**
+     * Resolve the response from a stateResponse configuration with matched condition.
+     *
+     * Returns both the response and the matched condition, enabling callers
+     * to determine which afterResponse to apply (condition-level or mock-level).
+     *
+     * @param stateResponse - The stateResponse configuration
+     * @param currentState - Current test state
+     * @returns Result with response and matched condition (null if default was used)
+     */
+    resolveResponseWithCondition(stateResponse: StatefulMockResponse, currentState: Readonly<Record<string, unknown>>): StateResponseResult;
 };
 /**
  * Options for creating a StateResponseResolver.

package/dist/domain/state-response-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state-response-resolver.d.ts","sourceRoot":"","sources":["../../src/domain/state-response-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAC9E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAE3E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAE9E;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC;;;;;;OAMG;IACH,eAAe,CACb,aAAa,EAAE,oBAAoB,EACnC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAC9C,iBAAiB,CAAC;CACtB,CAAC;AAEF;;GAEG;AACH,KAAK,kCAAkC,GAAG;IACxC;;;OAGG;IACH,SAAS,CAAC,EAAE,uBAAuB,CAAC;CACrC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,2BAA2B,GACtC,UAAS,kCAAuC,KAC/C,qBAoBF,CAAC"}
+{"version":3,"file":"state-response-resolver.d.ts","sourceRoot":"","sources":["../../src/domain/state-response-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,cAAc,EACf,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAE3E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAE9E;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,gBAAgB,EAAE,cAAc,GAAG,IAAI,CAAC;CAClD,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC;;;;;;;OAOG;IACH,eAAe,CACb,aAAa,EAAE,oBAAoB,EACnC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAC9C,iBAAiB,CAAC;IAErB;;;;;;;;;OASG;IACH,4BAA4B,CAC1B,aAAa,EAAE,oBAAoB,EACnC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAC9C,mBAAmB,CAAC;CACxB,CAAC;AAEF;;GAEG;AACH,KAAK,kCAAkC,GAAG;IACxC;;;OAGG;IACH,SAAS,CAAC,EAAE,uBAAuB,CAAC;CACrC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,2BAA2B,GACtC,UAAS,kCAAuC,KAC/C,qBAqCF,CAAC"}

package/dist/domain/state-response-resolver.js

@@ -6,11 +6,21 @@ export const createStateResponseResolver = (options = {}) => {
     const evaluator = options.evaluator ?? createStateConditionEvaluator();
     return {
         resolveResponse(stateResponse, currentState) {
+            const result = this.resolveResponseWithCondition(stateResponse, currentState);
+            return result.response;
+        },
+        resolveResponseWithCondition(stateResponse, currentState) {
             const matchingCondition = evaluator.findMatchingCondition(stateResponse.conditions, currentState);
             if (matchingCondition) {
-                return matchingCondition.then;
+                return {
+                    response: matchingCondition.then,
+                    matchedCondition: matchingCondition,
+                };
             }
-            return stateResponse.default;
+            return {
+                response: stateResponse.default,
+                matchedCondition: null,
+            };
         },
     };
 };

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

@@ -95,5 +95,17 @@ export interface ScenarioManager {
      * @returns Scenario definition or undefined if not found
      */
     getScenarioById(id: string): ScenaristScenario | undefined;
+    /**
+     * Get the current state for a test ID.
+     *
+     * Delegates to: StateManager.getAll()
+     *
+     * Useful for debugging test state during test development.
+     * Returns empty object if no state has been set or no stateManager is configured.
+     *
+     * @param testId Unique identifier for the test
+     * @returns Current state (read-only), or empty object if no state
+     */
+    getState(testId: string): Readonly<Record<string, unknown>>;
 }
 //# sourceMappingURL=scenario-manager.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"scenario-manager.d.ts","sourceRoot":"","sources":["../../../src/ports/driving/scenario-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EACd,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"scenario-manager.d.ts","sourceRoot":"","sources":["../../../src/ports/driving/scenario-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EACd,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;IAE3D;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC7D"}

package/dist/schemas/scenario-definition.d.ts

@@ -207,6 +207,9 @@ export declare const ScenaristMockSchema: z.ZodObject<{
                 headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                 delay: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>;
+            afterResponse: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                setState: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     captureState: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -307,6 +310,9 @@ export declare const ScenaristScenarioSchema: z.ZodObject<{
                     headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                     delay: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strip>;
+                afterResponse: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    setState: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.core.$strip>>>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
         captureState: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;

package/dist/schemas/scenario-definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scenario-definition.d.ts","sourceRoot":"","sources":["../../src/schemas/scenario-definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,OAAO,EAAE,uBAAuB,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEhF;;;;;;GAMG;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;EAQ3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;mBA4B3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,gBAAgB;;;;EAAoC,CAAC;AAClE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;iBAGlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,4BAA4B,uCAAmC,CAAC;AAC7E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,iEAGpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsB7B,CAAC;AACJ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}
+{"version":3,"file":"scenario-definition.d.ts","sourceRoot":"","sources":["../../src/schemas/scenario-definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,OAAO,EAAE,uBAAuB,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEhF;;;;;;GAMG;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;EAQ3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;mBA4B3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,gBAAgB;;;;EAAoC,CAAC;AAClE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;iBAGlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,4BAA4B,uCAAmC,CAAC;AAC7E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,iEAGpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsB7B,CAAC;AACJ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/schemas/scenarios-object.d.ts

@@ -101,6 +101,9 @@ export declare const ScenariosObjectSchema: z.ZodRecord<z.ZodString, z.ZodObject
                     headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                     delay: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strip>;
+                afterResponse: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    setState: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.core.$strip>>>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
         captureState: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;

package/dist/schemas/scenarios-object.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scenarios-object.d.ts","sourceRoot":"","sources":["../../src/schemas/scenarios-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAI9B,CAAC"}
+{"version":3,"file":"scenarios-object.d.ts","sourceRoot":"","sources":["../../src/schemas/scenarios-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAI9B,CAAC"}

package/dist/schemas/state-aware-mocking.d.ts

@@ -13,11 +13,17 @@ import { z } from "zod";
  * The `when` clause is a partial match object - all keys must match
  * the current state for the condition to apply.
  *
+ * The optional `afterResponse` field overrides the mock-level afterResponse:
+ * - If present with a value: use condition's afterResponse (replaces mock-level)
+ * - If present as null: explicitly skip state mutation
+ * - If absent: inherit mock-level afterResponse (backward compatible)
+ *
  * @example
  * ```typescript
  * {
  *   when: { checked: true, step: 'reviewed' },
- *   then: { status: 200, body: { state: 'approved' } }
+ *   then: { status: 200, body: { state: 'approved' } },
+ *   afterResponse: { setState: { phase: 'approved' } }  // Optional
  * }
  * ```
  */
@@ -29,6 +35,9 @@ export declare const StateConditionSchema: z.ZodObject<{
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         delay: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
+    afterResponse: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        setState: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type StateCondition = z.infer<typeof StateConditionSchema>;
 /**
@@ -62,6 +71,9 @@ export declare const StatefulMockResponseSchema: z.ZodObject<{
             headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             delay: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>;
+        afterResponse: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            setState: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type StatefulMockResponse = z.infer<typeof StatefulMockResponseSchema>;

package/dist/schemas/state-aware-mocking.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state-aware-mocking.d.ts","sourceRoot":"","sources":["../../src/schemas/state-aware-mocking.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;GAOG;AAEH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;iBAO/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;iBAGrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,wBAAwB;;iBAMnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,wCAAoC,CAAC;AAC1E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}
+{"version":3,"file":"state-aware-mocking.d.ts","sourceRoot":"","sources":["../../src/schemas/state-aware-mocking.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;iBAiB/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAkClE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;iBAQnC,CAAC;AACL,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,wBAAwB;;iBAMnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,wCAAoC,CAAC;AAC1E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/schemas/state-aware-mocking.js

@@ -14,11 +14,17 @@ import { ScenaristResponseSchema } from "./response.js";
  * The `when` clause is a partial match object - all keys must match
  * the current state for the condition to apply.
  *
+ * The optional `afterResponse` field overrides the mock-level afterResponse:
+ * - If present with a value: use condition's afterResponse (replaces mock-level)
+ * - If present as null: explicitly skip state mutation
+ * - If absent: inherit mock-level afterResponse (backward compatible)
+ *
  * @example
  * ```typescript
  * {
  *   when: { checked: true, step: 'reviewed' },
- *   then: { status: 200, body: { state: 'approved' } }
+ *   then: { status: 200, body: { state: 'approved' } },
+ *   afterResponse: { setState: { phase: 'approved' } }  // Optional
  * }
  * ```
  */
@@ -29,7 +35,45 @@ export const StateConditionSchema = z.object({
         message: "when clause must have at least one key",
     }),
     then: ScenaristResponseSchema,
+    afterResponse: z
+        .object({
+        setState: z
+            .record(z.string(), z.unknown())
+            .refine((obj) => Object.keys(obj).length > 0, {
+            message: "setState must have at least one key",
+        }),
+    })
+        .nullable()
+        .optional(),
 });
+/**
+ * Normalize a when clause to a canonical string for comparison.
+ * Sorts keys alphabetically and stringifies the object.
+ */
+const normalizeWhenClause = (when) => {
+    const sortedKeys = Object.keys(when).sort();
+    const sortedObj = {};
+    for (const key of sortedKeys) {
+        sortedObj[key] = when[key];
+    }
+    return JSON.stringify(sortedObj);
+};
+/**
+ * Check for duplicate when clauses in conditions array.
+ * Two when clauses are considered duplicates if they have the same keys
+ * with the same values, regardless of key order.
+ */
+const hasDuplicateWhenClauses = (conditions) => {
+    const seen = new Set();
+    for (const condition of conditions) {
+        const normalized = normalizeWhenClause(condition.when);
+        if (seen.has(normalized)) {
+            return true;
+        }
+        seen.add(normalized);
+    }
+    return false;
+};
 /**
  * Schema for stateful mock response (stateResponse).
  *
@@ -46,9 +90,13 @@ export const StateConditionSchema = z.object({
  * }
  * ```
  */
-export const StatefulMockResponseSchema = z.object({
+export const StatefulMockResponseSchema = z
+    .object({
     default: ScenaristResponseSchema,
     conditions: z.array(StateConditionSchema),
+})
+    .refine((data) => !hasDuplicateWhenClauses(data.conditions), {
+    message: "Duplicate 'when' clauses found in stateResponse conditions. Each condition must have a unique 'when' clause.",
 });
 /**
  * Schema for afterResponse configuration.

package/dist/types/config.d.ts

@@ -50,6 +50,8 @@ export type ScenaristConfig = {
         readonly setScenario: string;
         /** Endpoint to get current scenario (default: '/__scenario__') */
         readonly getScenario: string;
+        /** Endpoint to get current test state for debugging (default: '/__scenarist__/state') */
+        readonly getState: string;
     };
     /**
      * The default test ID to use when no x-scenarist-test-id header is present.

package/dist/types/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/types/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;AAExD;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,qEAAqE;IACrE,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,mEAAmE;IACnE,QAAQ,CAAC,mBAAmB,EAAE,aAAa,CAAC;IAC5C,iFAAiF;IACjF,QAAQ,CAAC,eAAe,EAAE,aAAa,CAAC;CACzC,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAE1B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAE7B;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE;QAClB,kEAAkE;QAClE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;QAC7B,kEAAkE;QAClE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;KAC9B,CAAC;IAEF;;OAEG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAE/B;;;OAGG;IACH,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;CACzC,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,oBAAoB,CAC9B,CAAC,SAAS,kBAAkB,GAAG,kBAAkB,IAC/C;IACF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC,CAAC;IAC3D;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC;IACtB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC;;OAEG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;CACnD,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/types/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;AAExD;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,qEAAqE;IACrE,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,mEAAmE;IACnE,QAAQ,CAAC,mBAAmB,EAAE,aAAa,CAAC;IAC5C,iFAAiF;IACjF,QAAQ,CAAC,eAAe,EAAE,aAAa,CAAC;CACzC,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAE1B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAE7B;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE;QAClB,kEAAkE;QAClE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;QAC7B,kEAAkE;QAClE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;QAC7B,yFAAyF;QACzF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;KAC3B,CAAC;IAEF;;OAEG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAE/B;;;OAGG;IACH,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;CACzC,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,oBAAoB,CAC9B,CAAC,SAAS,kBAAkB,GAAG,kBAAkB,IAC/C;IACF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC,CAAC;IAC3D;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC;IACtB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC;;OAEG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;CACnD,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scenarist/core",
-  "version": "0.3.3",
+  "version": "0.4.1",
   "description": "Internal: Hexagonal architecture core for scenario-based testing with MSW",
   "author": "Paul Hammond (citypaul) <paul@packsoftware.co.uk>",
   "license": "MIT",
@@ -56,8 +56,8 @@
     "fast-check": "^4.3.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.15",
-    "@scenarist/typescript-config": "0.0.0",
-    "@scenarist/eslint-config": "0.0.0"
+    "@scenarist/eslint-config": "0.0.0",
+    "@scenarist/typescript-config": "0.0.0"
   },
   "scripts": {
     "build": "tsc",