@step-forge/step-forge 0.0.11 → 0.0.13

package/dist/step-forge.cjs

@@ -0,0 +1,727 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _cucumber_cucumber = require("@cucumber/cucumber");
+let lodash = require("lodash");
+lodash = __toESM(lodash, 1);
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let typescript = require("typescript");
+typescript = __toESM(typescript, 1);
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs, 1);
+let _cucumber_gherkin = require("@cucumber/gherkin");
+let _cucumber_messages = require("@cucumber/messages");
+_cucumber_messages = __toESM(_cucumber_messages, 1);
+//#region src/builderTypeUtils.ts
+const isString = (statement) => typeof statement === "string";
+//#endregion
+//#region src/utils.ts
+const requireFromGiven = (keys, world) => {
+	keys.forEach((key) => {
+		if (!world.given[key]) throw new Error(`Key ${String(key)} is required in given state`);
+	});
+	return keys.reduce((acc, key) => {
+		return {
+			...acc,
+			[key]: world.given[key]
+		};
+	}, {});
+};
+const requireFromWhen = (keys, world) => {
+	keys.forEach((key) => {
+		if (!world.when[key]) throw new Error(`Key ${String(key)} is required in when state`);
+	});
+	return keys.reduce((acc, key) => {
+		return {
+			...acc,
+			[key]: world.when[key]
+		};
+	}, {});
+};
+const requireFromThen = (keys, world) => {
+	keys.forEach((key) => {
+		if (!world.then[key]) throw new Error(`Key ${String(key)} is required in then state`);
+	});
+	return keys.reduce((acc, key) => {
+		return {
+			...acc,
+			[key]: world.then[key]
+		};
+	}, {});
+};
+const typeCoercer = (value) => {
+	const numberValue = parseInt(value, 10);
+	if (!isNaN(numberValue)) return numberValue;
+	if (value === "true") return true;
+	if (value === "false") return false;
+	return value;
+};
+//#endregion
+//#region src/common.ts
+const cucFunctionMap = {
+	given: _cucumber_cucumber.Given,
+	when: _cucumber_cucumber.When,
+	then: _cucumber_cucumber.Then
+};
+const addStep = (statement, stepType, dependencies = {
+	given: {},
+	when: {},
+	then: {}
+}) => (stepFunction) => {
+	const statementFunction = statement;
+	const { given: givenDependencies, when: whenDependencies, then: thenDependencies } = dependencies;
+	return {
+		statement,
+		dependencies,
+		stepType,
+		stepFunction,
+		register: () => {
+			const argCount = statementFunction.length;
+			const statement = statementFunction(...Array.from({ length: argCount }, () => "{string}"));
+			const cucStepFunction = Object.defineProperty(async function(...args) {
+				const coercedArgs = args.map(typeCoercer);
+				const ensuredGivenValues = requireFromGiven(Object.entries(givenDependencies ?? {}).filter(([, value]) => value === "required").map(([key]) => key), this);
+				const narrowedGiven = {
+					...lodash.default.pick(this.given, Object.keys(givenDependencies ?? {})),
+					...ensuredGivenValues
+				};
+				const ensuredWhenValues = requireFromWhen(Object.entries(whenDependencies ?? {}).filter(([, value]) => value === "required").map(([key]) => key), this);
+				const narrowedWhen = {
+					...lodash.default.pick(this.when, Object.keys(whenDependencies ?? {})),
+					...ensuredWhenValues
+				};
+				const ensuredThenValues = requireFromThen(Object.entries(thenDependencies ?? {}).filter(([, value]) => value === "required").map(([key]) => key), this);
+				const result = await stepFunction({
+					variables: coercedArgs,
+					given: narrowedGiven,
+					when: narrowedWhen,
+					then: {
+						...lodash.default.pick(this.then, Object.keys(thenDependencies ?? {})),
+						...ensuredThenValues
+					}
+				});
+				this[stepType].merge({ ...result });
+			}, "length", {
+				value: argCount,
+				configurable: true
+			});
+			const cucStep = cucFunctionMap[stepType];
+			cucStep(statement, cucStepFunction);
+			return {
+				stepType,
+				dependencies,
+				statement: statementFunction,
+				stepFunction
+			};
+		}
+	};
+};
+//#endregion
+//#region src/given.ts
+const givenDependencies = (statement, stepType) => (dependencies) => {
+	return { step: addStep(statement, stepType, {
+		...dependencies,
+		when: {},
+		then: {}
+	}) };
+};
+const givenStatement = (stepType) => (statement) => {
+	let normalizedStatement;
+	if (isString(statement)) normalizedStatement = (() => statement);
+	else normalizedStatement = statement;
+	return {
+		dependencies: givenDependencies(normalizedStatement, stepType),
+		step: addStep(normalizedStatement, stepType)
+	};
+};
+const givenBuilder = () => {
+	return { statement: givenStatement("given") };
+};
+//#endregion
+//#region src/when.ts
+const whenDependencies = (statement, stepType) => (dependencies) => {
+	return { step: addStep(statement, stepType, {
+		given: dependencies.given ?? {},
+		when: dependencies.when ?? {},
+		then: {}
+	}) };
+};
+const whenStatement = (stepType) => (statement) => {
+	let normalizedStatement;
+	if (isString(statement)) normalizedStatement = (() => statement);
+	else normalizedStatement = statement;
+	return {
+		dependencies: whenDependencies(normalizedStatement, stepType),
+		step: addStep(normalizedStatement, stepType)
+	};
+};
+const whenBuilder = () => {
+	return { statement: whenStatement("when") };
+};
+//#endregion
+//#region src/then.ts
+const thenDependencies = (statement, stepType) => (dependencies) => {
+	return { step: addStep(statement, stepType, {
+		given: dependencies.given ?? {},
+		when: dependencies.when ?? {},
+		then: dependencies.then ?? {}
+	}) };
+};
+const thenStatement = (stepType) => (statement) => {
+	let normalizedStatement;
+	if (isString(statement)) normalizedStatement = (() => statement);
+	else normalizedStatement = statement;
+	return {
+		dependencies: thenDependencies(normalizedStatement, stepType),
+		step: addStep(normalizedStatement, stepType)
+	};
+};
+const thenBuilder = () => {
+	return { statement: thenStatement("then") };
+};
+//#endregion
+//#region src/world.ts
+function mergeCustomizer(objValue, srcValue) {
+	if (lodash.default.isArray(objValue)) return objValue.concat(srcValue);
+	else if (objValue && !lodash.default.isPlainObject(objValue) && objValue !== srcValue) throw new Error(`Merge would have destroyed previous value ${objValue} with ${srcValue}`);
+	return objValue;
+}
+var BasicWorld = class {
+	givenState = {};
+	whenState = {};
+	thenState = {};
+	get given() {
+		return {
+			...this.givenState,
+			merge: (newState) => {
+				this.givenState = lodash.default.merge({ ...this.givenState }, newState, mergeCustomizer);
+			}
+		};
+	}
+	get when() {
+		return {
+			...this.whenState,
+			merge: (newState) => {
+				this.whenState = lodash.default.merge({ ...this.whenState }, newState, mergeCustomizer);
+			}
+		};
+	}
+	get then() {
+		return {
+			...this.thenState,
+			merge: (newState) => {
+				this.thenState = lodash.default.merge({ ...this.thenState }, newState, mergeCustomizer);
+			}
+		};
+	}
+};
+//#endregion
+//#region src/analyzer/stepExtractor.ts
+const BUILDER_NAMES = {
+	givenBuilder: "given",
+	whenBuilder: "when",
+	thenBuilder: "then"
+};
+function extractStepDefinitions(filePaths, tsConfigPath) {
+	const configPath = tsConfigPath ?? typescript.default.findConfigFile(process.cwd(), typescript.default.sys.fileExists);
+	let compilerOptions = {
+		target: typescript.default.ScriptTarget.ESNext,
+		module: typescript.default.ModuleKind.ESNext,
+		moduleResolution: typescript.default.ModuleResolutionKind.Node10,
+		strict: true,
+		esModuleInterop: true
+	};
+	if (configPath) {
+		const configFile = typescript.default.readConfigFile(configPath, typescript.default.sys.readFile);
+		if (!configFile.error) compilerOptions = typescript.default.parseJsonConfigFileContent(configFile.config, typescript.default.sys, configPath.replace(/[/\\][^/\\]+$/, "")).options;
+	}
+	compilerOptions.noEmit = true;
+	const program = typescript.default.createProgram(filePaths, compilerOptions);
+	const checker = program.getTypeChecker();
+	const results = [];
+	for (const filePath of filePaths) {
+		const sourceFile = program.getSourceFile(filePath);
+		if (!sourceFile) continue;
+		const fileResults = extractFromSourceFile(sourceFile, checker);
+		results.push(...fileResults);
+	}
+	return results;
+}
+function extractFromSourceFile(sourceFile, checker) {
+	const results = [];
+	function visit(node) {
+		if (typescript.default.isCallExpression(node) && typescript.default.isPropertyAccessExpression(node.expression) && node.expression.name.text === "register") {
+			const meta = extractFromRegisterCall(node, sourceFile, checker);
+			if (meta) results.push(meta);
+		}
+		typescript.default.forEachChild(node, visit);
+	}
+	visit(sourceFile);
+	return results;
+}
+function extractFromRegisterCall(registerCall, sourceFile, checker) {
+	const chain = collectCallChain(registerCall);
+	let stepType = null;
+	let expression = null;
+	let dependencies = {
+		given: {},
+		when: {},
+		then: {}
+	};
+	let produces = [];
+	for (const link of chain) {
+		const name = getCallName(link);
+		if (!name) continue;
+		if (name === "register") continue;
+		if (name === "step") {
+			produces = extractProducedKeys(link, checker);
+			continue;
+		}
+		if (name === "dependencies") {
+			dependencies = extractDependencies(link);
+			continue;
+		}
+		if (name === "statement") {
+			expression = extractExpression(link);
+			continue;
+		}
+		if (BUILDER_NAMES[name]) {
+			stepType = BUILDER_NAMES[name];
+			continue;
+		}
+	}
+	if (!stepType || !expression) {
+		const reExport = resolveReExportedCall(chain, checker);
+		if (reExport) {
+			if (!stepType) stepType = reExport.stepType;
+			if (!expression) expression = reExport.expression;
+		}
+	}
+	if (!stepType || !expression) return null;
+	const line = sourceFile.getLineAndCharacterOfPosition(registerCall.getStart()).line + 1;
+	return {
+		stepType,
+		expression,
+		dependencies,
+		produces,
+		sourceFile: sourceFile.fileName,
+		line
+	};
+}
+/**
+* Collect all call expressions in the method chain, from register() back to the origin.
+*/
+function collectCallChain(call) {
+	const chain = [call];
+	let current = call.expression;
+	while (true) {
+		if (typescript.default.isPropertyAccessExpression(current)) current = current.expression;
+		if (typescript.default.isCallExpression(current)) {
+			chain.push(current);
+			current = current.expression;
+		} else break;
+	}
+	return chain;
+}
+function getCallName(call) {
+	const expr = call.expression;
+	if (typescript.default.isPropertyAccessExpression(expr)) return expr.name.text;
+	if (typescript.default.isIdentifier(expr)) return expr.text;
+	return null;
+}
+function extractExpression(statementCall) {
+	const arg = statementCall.arguments[0];
+	if (!arg) return null;
+	if (typescript.default.isStringLiteral(arg)) return arg.text;
+	if (typescript.default.isArrowFunction(arg)) return extractExpressionFromArrowFunction(arg);
+	return null;
+}
+function extractExpressionFromArrowFunction(fn) {
+	const params = fn.parameters.map((p) => p.name.getText());
+	let body = fn.body;
+	if (typescript.default.isBlock(body)) {
+		const returnStmt = body.statements.find(typescript.default.isReturnStatement);
+		if (returnStmt?.expression) body = returnStmt.expression;
+		else return null;
+	}
+	if (typescript.default.isTemplateExpression(body)) return reconstructExpressionFromTemplate(body, params);
+	if (typescript.default.isNoSubstitutionTemplateLiteral(body)) return body.text;
+	return null;
+}
+function reconstructExpressionFromTemplate(template, paramNames) {
+	let result = template.head.text;
+	for (const span of template.templateSpans) {
+		if (typescript.default.isIdentifier(span.expression) && paramNames.includes(span.expression.text)) result += "{string}";
+		else result += "{string}";
+		result += span.literal.text;
+	}
+	return result;
+}
+function extractDependencies(depsCall) {
+	const deps = {
+		given: {},
+		when: {},
+		then: {}
+	};
+	const arg = depsCall.arguments[0];
+	if (!arg || !typescript.default.isObjectLiteralExpression(arg)) return deps;
+	for (const prop of arg.properties) {
+		if (!typescript.default.isPropertyAssignment(prop) || !typescript.default.isIdentifier(prop.name)) continue;
+		const phase = prop.name.text;
+		if (!deps[phase]) continue;
+		if (typescript.default.isObjectLiteralExpression(prop.initializer)) {
+			for (const innerProp of prop.initializer.properties) if (typescript.default.isPropertyAssignment(innerProp) && typescript.default.isIdentifier(innerProp.name) && typescript.default.isStringLiteral(innerProp.initializer)) {
+				const val = innerProp.initializer.text;
+				if (val === "required" || val === "optional") deps[phase][innerProp.name.text] = val;
+			}
+		}
+	}
+	return deps;
+}
+function extractProducedKeys(stepCall, checker) {
+	const callback = stepCall.arguments[0];
+	if (!callback) return [];
+	if (typescript.default.isArrowFunction(callback) || typescript.default.isFunctionExpression(callback)) return extractProducedKeysFromCallback(callback, checker);
+	return [];
+}
+function extractProducedKeysFromCallback(callback, checker) {
+	const body = callback.body;
+	if (!typescript.default.isBlock(body)) return extractKeysFromExpression(body, checker);
+	const keys = /* @__PURE__ */ new Set();
+	function visitReturn(node) {
+		if (typescript.default.isReturnStatement(node) && node.expression) for (const key of extractKeysFromExpression(node.expression, checker)) keys.add(key);
+		typescript.default.forEachChild(node, visitReturn);
+	}
+	visitReturn(body);
+	return [...keys];
+}
+function extractKeysFromExpression(expr, checker) {
+	while (typescript.default.isParenthesizedExpression(expr)) expr = expr.expression;
+	if (typescript.default.isObjectLiteralExpression(expr)) return expr.properties.filter((p) => typescript.default.isPropertyAssignment(p) || typescript.default.isShorthandPropertyAssignment(p)).map((p) => p.name.getText()).filter(Boolean);
+	try {
+		return checker.getTypeAtLocation(expr).getProperties().map((p) => p.name).filter((n) => n !== "merge");
+	} catch {
+		return [];
+	}
+}
+function resolveReExportedCall(chain, checker) {
+	const lastCall = chain[chain.length - 1];
+	if (!lastCall) return null;
+	const expr = lastCall.expression;
+	let identifier = null;
+	if (typescript.default.isIdentifier(expr)) identifier = expr;
+	else if (typescript.default.isPropertyAccessExpression(expr) && typescript.default.isIdentifier(expr.expression)) identifier = expr.expression;
+	if (!identifier) return null;
+	const symbol = checker.getSymbolAtLocation(identifier);
+	if (!symbol) return null;
+	const decl = symbol.valueDeclaration;
+	if (!decl || !typescript.default.isVariableDeclaration(decl) || !decl.initializer) return null;
+	const init = decl.initializer;
+	if (typescript.default.isPropertyAccessExpression(init) && init.name.text === "statement") {
+		const callExpr = init.expression;
+		if (typescript.default.isCallExpression(callExpr)) {
+			const callee = callExpr.expression;
+			if (typescript.default.isIdentifier(callee) && BUILDER_NAMES[callee.text]) {
+				const expression = extractExpression(lastCall);
+				return {
+					stepType: BUILDER_NAMES[callee.text],
+					expression
+				};
+			}
+		}
+	}
+	return null;
+}
+//#endregion
+//#region src/analyzer/gherkinParser.ts
+function parseFeatureFiles(filePaths) {
+	const scenarios = [];
+	for (const filePath of filePaths) {
+		const parsed = parseFeatureContent(node_fs.readFileSync(filePath, "utf-8"), filePath);
+		scenarios.push(...parsed);
+	}
+	return scenarios;
+}
+function parseFeatureContent(content, filePath) {
+	const feature = new _cucumber_gherkin.Parser(new _cucumber_gherkin.AstBuilder(_cucumber_messages.IdGenerator.uuid()), new _cucumber_gherkin.GherkinClassicTokenMatcher()).parse(content).feature;
+	if (!feature) return [];
+	const featureBackground = [];
+	const scenarios = [];
+	for (const child of feature.children) {
+		if (child.background) featureBackground.push(...child.background.steps);
+		if (child.scenario) scenarios.push(...expandScenario(child.scenario, featureBackground, filePath));
+		if (child.rule) {
+			const ruleBackground = [...featureBackground];
+			for (const ruleChild of child.rule.children) {
+				if (ruleChild.background) ruleBackground.push(...ruleChild.background.steps);
+				if (ruleChild.scenario) scenarios.push(...expandScenario(ruleChild.scenario, ruleBackground, filePath));
+			}
+		}
+	}
+	return scenarios;
+}
+function expandScenario(scenario, backgroundSteps, filePath) {
+	if (!(scenario.examples.length > 0 && scenario.examples.some((e) => e.tableBody.length > 0))) {
+		const bgParsed = convertSteps(backgroundSteps);
+		const scenarioParsed = convertSteps(scenario.steps);
+		const allSteps = resolveEffectiveKeywords([...bgParsed, ...scenarioParsed]);
+		return [{
+			name: scenario.name,
+			file: filePath,
+			steps: allSteps
+		}];
+	}
+	const results = [];
+	for (const example of scenario.examples) {
+		if (!example.tableHeader || example.tableBody.length === 0) continue;
+		const headers = example.tableHeader.cells.map((c) => c.value);
+		for (const row of example.tableBody) {
+			const values = row.cells.map((c) => c.value);
+			const substitution = {};
+			headers.forEach((h, i) => {
+				substitution[h] = values[i];
+			});
+			const bgParsed = convertSteps(backgroundSteps);
+			const scenarioSteps = convertSteps(scenario.steps).map((step) => ({
+				...step,
+				text: substituteExampleValues(step.text, substitution)
+			}));
+			const allSteps = resolveEffectiveKeywords([...bgParsed, ...scenarioSteps]);
+			results.push({
+				name: `${scenario.name} (${values.join(", ")})`,
+				file: filePath,
+				steps: allSteps
+			});
+		}
+	}
+	return results;
+}
+function convertSteps(steps) {
+	return steps.map((step) => ({
+		keyword: normalizeKeyword(step.keyword),
+		text: step.text,
+		line: step.location.line,
+		column: (step.location.column ?? 1) + step.keyword.length
+	}));
+}
+function normalizeKeyword(keyword) {
+	const trimmed = keyword.trim();
+	if (trimmed === "Given") return "Given";
+	if (trimmed === "When") return "When";
+	if (trimmed === "Then") return "Then";
+	if (trimmed === "And") return "And";
+	if (trimmed === "But") return "But";
+	return "Given";
+}
+function resolveEffectiveKeywords(steps) {
+	let lastEffective = "Given";
+	return steps.map((step) => {
+		let effectiveKeyword;
+		if (step.keyword === "And" || step.keyword === "But") effectiveKeyword = lastEffective;
+		else effectiveKeyword = step.keyword;
+		lastEffective = effectiveKeyword;
+		return {
+			...step,
+			effectiveKeyword
+		};
+	});
+}
+function substituteExampleValues(text, substitution) {
+	let result = text;
+	for (const [key, value] of Object.entries(substitution)) result = result.replace(new RegExp(`<${key}>`, "g"), value);
+	return result;
+}
+//#endregion
+//#region src/analyzer/stepMatcher.ts
+function compileDefinitions(definitions) {
+	const compiled = [];
+	for (const def of definitions) try {
+		const placeholder = "###PLACEHOLDER###";
+		const regexStr = def.expression.replace(/\{[^}]+\}/g, placeholder).replace(/[.*+?^$()|[\]\\]/g, "\\$&").replace(new RegExp(placeholder, "g"), "(.+)");
+		compiled.push({
+			regex: new RegExp(`^${regexStr}$`, "i"),
+			definition: def
+		});
+	} catch {}
+	return compiled;
+}
+function matchScenarioSteps(scenario, definitions) {
+	const compiled = compileDefinitions(definitions);
+	return scenario.steps.map((step) => {
+		const matches = findMatches(step.text, step.effectiveKeyword, compiled);
+		return {
+			...step,
+			definitions: matches
+		};
+	});
+}
+function findMatchingDefinitions(text, effectiveKeyword, definitions) {
+	return findMatches(text, effectiveKeyword, compileDefinitions(definitions));
+}
+function findMatches(text, effectiveKeyword, compiled) {
+	const expectedStepType = {
+		Given: "given",
+		When: "when",
+		Then: "then"
+	}[effectiveKeyword];
+	const typedMatches = [];
+	for (const { regex, definition } of compiled) {
+		if (definition.stepType !== expectedStepType) continue;
+		if (regex.test(text)) typedMatches.push(definition);
+	}
+	if (typedMatches.length > 0) return typedMatches;
+	const fallbackMatches = [];
+	for (const { regex, definition } of compiled) if (regex.test(text)) fallbackMatches.push(definition);
+	return fallbackMatches;
+}
+//#endregion
+//#region src/analyzer/rules/index.ts
+const defaultRules = [
+	{
+		name: "undefined-step",
+		check(scenario, matchedSteps) {
+			return matchedSteps.filter((step) => step.definitions.length === 0).map((step) => ({
+				file: scenario.file,
+				range: {
+					startLine: step.line,
+					startColumn: step.column,
+					endLine: step.line,
+					endColumn: step.column + step.text.length
+				},
+				severity: "error",
+				message: `Step "${step.text}" does not match any step definition`,
+				rule: "undefined-step",
+				source: "step-forge"
+			}));
+		}
+	},
+	{
+		name: "ambiguous-step",
+		check(scenario, matchedSteps) {
+			return matchedSteps.filter((step) => step.definitions.length > 1).map((step) => {
+				const locations = step.definitions.map((d) => `${d.sourceFile}:${d.line}`).join(", ");
+				return {
+					file: scenario.file,
+					range: {
+						startLine: step.line,
+						startColumn: step.column,
+						endLine: step.line,
+						endColumn: step.column + step.text.length
+					},
+					severity: "error",
+					message: `Step "${step.text}" matches multiple step definitions: ${locations}`,
+					rule: "ambiguous-step",
+					source: "step-forge"
+				};
+			});
+		}
+	},
+	{
+		name: "dependency-check",
+		check(scenario, matchedSteps) {
+			const diagnostics = [];
+			const produced = {
+				given: /* @__PURE__ */ new Set(),
+				when: /* @__PURE__ */ new Set(),
+				then: /* @__PURE__ */ new Set()
+			};
+			for (const step of matchedSteps) {
+				if (step.definitions.length !== 1) continue;
+				const { dependencies, produces, stepType } = step.definitions[0];
+				const missing = {};
+				for (const phase of [
+					"given",
+					"when",
+					"then"
+				]) for (const [key, requirement] of Object.entries(dependencies[phase])) if (requirement === "required" && !produced[phase].has(key)) {
+					if (!missing[phase]) missing[phase] = [];
+					missing[phase].push(key);
+				}
+				if (Object.keys(missing).length > 0) {
+					const message = "Missing required dependencies:\n" + Object.entries(missing).map(([phase, keys]) => `${phase.charAt(0).toUpperCase() + phase.slice(1)}: ${keys.map((k) => `${phase}.${k}`).join(", ")}`).join("\n");
+					diagnostics.push({
+						file: scenario.file,
+						range: {
+							startLine: step.line,
+							startColumn: step.column,
+							endLine: step.line,
+							endColumn: step.column + step.text.length
+						},
+						severity: "error",
+						message,
+						rule: "dependency-check",
+						source: "step-forge"
+					});
+				}
+				for (const key of produces) produced[stepType].add(key);
+			}
+			return diagnostics;
+		}
+	}
+];
+function runRules(rules, scenario, matchedSteps) {
+	return rules.flatMap((rule) => rule.check(scenario, matchedSteps));
+}
+//#endregion
+//#region src/analyzer/index.ts
+async function analyze(config, options) {
+	const rules = options?.rules ?? defaultRules;
+	const stepFilePaths = await resolveGlobs(config.stepFiles);
+	const featureFilePaths = await resolveGlobs(config.featureFiles);
+	if (stepFilePaths.length === 0) return [];
+	if (featureFilePaths.length === 0) return [];
+	const stepDefinitions = extractStepDefinitions(stepFilePaths, config.tsConfigPath);
+	const scenarios = parseFeatureFiles(featureFilePaths);
+	const diagnostics = [];
+	for (const scenario of scenarios) {
+		const scenarioDiags = runRules(rules, scenario, matchScenarioSteps(scenario, stepDefinitions));
+		diagnostics.push(...scenarioDiags);
+	}
+	return diagnostics;
+}
+async function resolveGlobs(patterns) {
+	const files = [];
+	for (const pattern of patterns) for await (const file of (0, node_fs_promises.glob)(pattern)) files.push(node_path.resolve(file));
+	return [...new Set(files)];
+}
+//#endregion
+//#region src/index.ts
+const analyzer = {
+	analyze,
+	extractStepDefinitions,
+	parseFeatureFiles,
+	parseFeatureContent,
+	matchScenarioSteps,
+	findMatchingDefinitions,
+	defaultRules
+};
+//#endregion
+exports.BasicWorld = BasicWorld;
+exports.analyzer = analyzer;
+exports.givenBuilder = givenBuilder;
+exports.thenBuilder = thenBuilder;
+exports.whenBuilder = whenBuilder;
+
+//# sourceMappingURL=step-forge.cjs.map