@shivaedev/quality 0.23.0 → 0.25.0

package/src/report/stale.ts

@@ -8,31 +8,39 @@ interface StaleFiles {
 	readonly registry: string;
 }
 
-const section = (label: string, file: string, guidance: string, lines: readonly string[]): readonly string[] =>
-	lines.length === 0 ? [] : [[`${label} ${file}: ${plural(lines.length, "stale entry", "stale entries")}`, `  ${guidance}`, ...lines].join("\n")];
+function section(label: string, file: string, guidance: string, lines: readonly string[]): readonly string[] {
+	return lines.length === 0
+		? []
+		: [[`${label} ${file}: ${plural(lines.length, "stale entry", "stale entries")}`, `  ${guidance}`, ...lines].join("\n")];
+}
 
-const baselineLine = ({ entry, problem }: StaleBaselineEntry): string => `  ${entry.rule} ${entry.file} ${problem}.`;
+function baselineLine({ entry, problem }: StaleBaselineEntry): string {
+	return `  ${entry.rule} ${entry.file} ${problem}.`;
+}
 
-const registryLine = ({ entry, problem }: StaleRegistryEntry): string =>
-	`  ${entry.rule} ${entry.file}${entry.subject === undefined ? "" : ` (${entry.subject})`} ${problem}.`;
+function registryLine({ entry, problem }: StaleRegistryEntry): string {
+	return `  ${entry.rule} ${entry.file}${entry.subject === undefined ? "" : ` (${entry.subject})`} ${problem}.`;
+}
 
-export const staleSections = (outcome: Outcome, files: StaleFiles): readonly string[] => [
-	...section(
-		"error",
-		files.baseline,
-		"An entry for a rule that is off or unknown covers nothing. Run `quality baseline prune` to drop it.",
-		outcome.staleBaseline.map(baselineLine),
-	),
-	...section(
-		"note",
-		files.baseline,
-		"These pass, and `quality baseline tighten` lowers them when their files change. `quality baseline prune` lowers them all.",
-		outcome.looseBaseline.map(baselineLine),
-	),
-	...section(
-		"error",
-		files.registry,
-		"Every registered exception must still apply. Remove the entries whose exception is gone.",
-		outcome.staleRegistry.map(registryLine),
-	),
-];
+export function staleSections(outcome: Outcome, files: StaleFiles): readonly string[] {
+	return [
+		...section(
+			"error",
+			files.baseline,
+			"An entry for an unknown rule covers nothing. Run `quality baseline prune` to drop it.",
+			outcome.staleBaseline.map(baselineLine),
+		),
+		...section(
+			"note",
+			files.baseline,
+			"These pass, and `quality baseline tighten` lowers them when their files change. `quality baseline prune` lowers them all.",
+			outcome.looseBaseline.map(baselineLine),
+		),
+		...section(
+			"error",
+			files.registry,
+			"Every registered exception must still apply. Remove the entries whose exception is gone.",
+			outcome.staleRegistry.map(registryLine),
+		),
+	];
+}

package/src/rule.ts

@@ -1,6 +1,6 @@
 import type { Bivariant } from "@shivaedev/types/bivariant.ts";
 import type { ExceptionDeclaration } from "#exceptions/declaration.ts";
-import { describeIssue, type StandardSchemaV1 } from "./standard-schema.ts";
+import { describeIssue, type StandardSchemaV1 } from "./standardSchema.ts";
 
 export interface Finding {
 	readonly count?: number | undefined;
@@ -28,35 +28,35 @@ export interface RuleInputs {
 	readonly sources: readonly SourceFile[];
 }
 
-export interface RuleContext<Options> extends RuleInputs {
-	readonly options: Options;
+export interface RuleContext<TOptions> extends RuleInputs {
+	readonly options: TOptions;
 }
 
 export type Configured =
 	| { readonly _tag: "Invalid"; readonly issues: readonly string[] }
 	| { readonly _tag: "Ready"; readonly check: (inputs: RuleInputs) => Promise<Findings> };
 
-export interface Rule<Id extends string = string, Input = unknown> {
+export interface Rule<TId extends string = string, TInput = unknown> {
 	// Bivariance keeps rules with different options in one list; configure validates its input at runtime.
-	configure: Bivariant<(options: Input | undefined) => Promise<Configured>>;
+	configure: Bivariant<(options: TInput | undefined) => Promise<Configured>>;
 	readonly description: string;
 	readonly family?: boolean;
-	readonly id: Id;
+	readonly id: TId;
 	readonly registrable?: boolean;
 }
 
-interface RuleDefinition<Id extends string, Options> {
-	readonly check: (context: RuleContext<Options>) => Findings | PromiseLike<Findings>;
+interface RuleDefinition<TId extends string, TOptions> {
+	readonly check: (context: RuleContext<TOptions>) => Findings | PromiseLike<Findings>;
 	readonly description: string;
-	readonly id: Id;
+	readonly id: TId;
 	readonly registrable?: false;
 }
 
-interface RuleDefinitionWithOptions<Id extends string, Input, Options> extends RuleDefinition<Id, Options> {
-	readonly options: StandardSchemaV1<Input, Options>;
+interface RuleDefinitionWithOptions<TId extends string, TInput, TOptions> extends RuleDefinition<TId, TOptions> {
+	readonly options: StandardSchemaV1<TInput, TOptions>;
 }
 
-interface RuleDefinitionWithoutOptions<Id extends string> extends RuleDefinition<Id, undefined> {
+interface RuleDefinitionWithoutOptions<TId extends string> extends RuleDefinition<TId, undefined> {
 	readonly options?: undefined;
 }
 
@@ -68,9 +68,12 @@ const noOptions: StandardSchemaV1<undefined, undefined> = {
 	},
 };
 
-const configureWith =
-	<Input, Options>(schema: StandardSchemaV1<Input, Options>, check: RuleDefinition<string, Options>["check"], absent: unknown) =>
-	async (options: unknown): Promise<Configured> => {
+function configureWith<TInput, TOptions>(
+	schema: StandardSchemaV1<TInput, TOptions>,
+	check: RuleDefinition<string, TOptions>["check"],
+	absent: unknown,
+) {
+	return async (options: unknown): Promise<Configured> => {
 		const result = await schema["~standard"].validate(options ?? absent);
 		if (result.issues !== undefined) {
 			return { _tag: "Invalid", issues: result.issues.map(describeIssue) };
@@ -78,12 +81,15 @@ const configureWith =
 		const value = result.value;
 		return { _tag: "Ready", check: async (inputs) => check({ ...inputs, options: value }) };
 	};
+}
 
-export function defineRule<const Id extends string, Input, Options>(definition: RuleDefinitionWithOptions<Id, Input, Options>): Rule<Id, Input>;
-export function defineRule<const Id extends string>(definition: RuleDefinitionWithoutOptions<Id>): Rule<Id, undefined>;
-export function defineRule<const Id extends string, Input, Options>(
-	definition: RuleDefinitionWithOptions<Id, Input, Options> | RuleDefinitionWithoutOptions<Id>,
-): Rule<Id, Input> | Rule<Id, undefined> {
+export function defineRule<const TId extends string, TInput, TOptions>(
+	definition: RuleDefinitionWithOptions<TId, TInput, TOptions>,
+): Rule<TId, TInput>;
+export function defineRule<const TId extends string>(definition: RuleDefinitionWithoutOptions<TId>): Rule<TId, undefined>;
+export function defineRule<const TId extends string, TInput, TOptions>(
+	definition: RuleDefinitionWithOptions<TId, TInput, TOptions> | RuleDefinitionWithoutOptions<TId>,
+): Rule<TId, TInput> | Rule<TId, undefined> {
 	const configure =
 		definition.options === undefined
 			? configureWith(noOptions, definition.check, undefined)

package/src/rules/{built-in.ts → builtIn.ts}

@@ -1,10 +1,10 @@
-import { maxPerFile } from "#rules/comments/max-per-file.ts";
-import { noBanner } from "#rules/comments/no-banner.ts";
-import { noEnvironmentPragma } from "#rules/comments/no-environment-pragma.ts";
-import { noJsdoc } from "#rules/comments/no-jsdoc.ts";
-import { noLineReference } from "#rules/comments/no-line-reference.ts";
-import { noPrReference } from "#rules/comments/no-pr-reference.ts";
-import { noTodo } from "#rules/comments/no-todo.ts";
+import { maxPerFile } from "#rules/comments/maxPerFile.ts";
+import { noBanner } from "#rules/comments/noBanner.ts";
+import { noEnvironmentPragma } from "#rules/comments/noEnvironmentPragma.ts";
+import { noJsdoc } from "#rules/comments/noJsdoc.ts";
+import { noLineReference } from "#rules/comments/noLineReference.ts";
+import { noPrReference } from "#rules/comments/noPrReference.ts";
+import { noTodo } from "#rules/comments/noTodo.ts";
 import { distinctCase } from "#rules/files/distinctCase.ts";
 import { folderNames } from "#rules/files/folderNames.ts";
 import { namedAfterExport } from "#rules/files/namedAfterExport.ts";
@@ -17,17 +17,19 @@ import { noTestCode } from "#rules/imports/noTestCode.ts";
 import { importsResolvable } from "#rules/imports/resolvable.ts";
 import { importsRuntime } from "#rules/imports/runtime.ts";
 import { storySetup } from "#rules/stories/setup.ts";
-import { biomeOverrides } from "#rules/suppressions/biome-overrides.ts";
+import { storySpecs } from "#rules/stories/specs.ts";
+import { biomeOverrides } from "#rules/suppressions/biomeOverrides.ts";
 import { biomeRecommended } from "#rules/suppressions/biomeRecommended.ts";
-import { noDoubleCast } from "#rules/suppressions/no-double-cast.ts";
-import { noInline } from "#rules/suppressions/no-inline.ts";
+import { noDoubleCast } from "#rules/suppressions/noDoubleCast.ts";
 import { noIgnoreDeprecations } from "#rules/suppressions/noIgnoreDeprecations.ts";
+import { noInline } from "#rules/suppressions/noInline.ts";
 import { testsColocated } from "#rules/test-names/colocated.ts";
 import { testsFollow } from "#rules/test-names/follow.ts";
 import { biome } from "./biome.ts";
-import { manifestsSorted } from "./manifests-sorted.ts";
-import { maxLines } from "./max-lines.ts";
+import { manifestsSorted } from "./manifestsSorted.ts";
+import { manifestsSourceFirst } from "./manifestsSourceFirst.ts";
 import { maxDepth } from "./maxDepth.ts";
+import { maxLines } from "./maxLines.ts";
 import { noBarrel } from "./noBarrel.ts";
 
 export const builtInRules = [
@@ -55,6 +57,7 @@ export const builtInRules = [
 	importsAliased,
 	noTestCode,
 	manifestsSorted,
+	manifestsSourceFirst,
 	namedAfterExport,
 	folderNames,
 	distinctCase,
@@ -62,4 +65,5 @@ export const builtInRules = [
 	testsFollow,
 	testsColocated,
 	storySetup,
+	storySpecs,
 ] as const;

package/src/rules/comments/{pattern-rule.ts → definePattern.ts}

@@ -9,13 +9,13 @@ interface PatternRule<Id extends string> {
 	readonly patterns: readonly RegExp[];
 }
 
-const firstMatch = (comment: SourceComment, patterns: readonly RegExp[]): string | undefined => {
+function firstMatch(comment: SourceComment, patterns: readonly RegExp[]): string | undefined {
 	const text = textOf(comment);
 	return patterns.map((pattern) => pattern.exec(text)?.[0]).find((match) => match !== undefined);
-};
+}
 
-export const definePatternRule = <const Id extends string>({ description, id, message, patterns }: PatternRule<Id>): Rule<Id, undefined> =>
-	defineRule({
+export function definePatternRule<const Id extends string>({ description, id, message, patterns }: PatternRule<Id>): Rule<Id, undefined> {
+	return defineRule({
 		check: ({ sources }) =>
 			sources.flatMap((file) =>
 				commentsOf(file).flatMap((comment): readonly Finding[] => {
@@ -26,3 +26,4 @@ export const definePatternRule = <const Id extends string>({ description, id, me
 		description,
 		id,
 	});
+}

package/src/rules/comments/kinds.ts

@@ -15,21 +15,28 @@ const DIRECTIVES: readonly RegExp[] = [
 
 const TRIPLE_SLASH = /^\/\/\/\s*</u;
 
-const contentOf = (comment: SourceComment): readonly string[] => comment.body.filter((line) => line !== "");
+function contentOf(comment: SourceComment): readonly string[] {
+	return comment.body.filter((line) => line !== "");
+}
 
-const startsWithTag = (line: string, tags: readonly string[]): boolean =>
-	tags.some((tag) => line === tag || line.startsWith(`${tag} `) || line.startsWith(`${tag}\t`));
+function startsWithTag(line: string, tags: readonly string[]): boolean {
+	return tags.some((tag) => line === tag || line.startsWith(`${tag} `) || line.startsWith(`${tag}\t`));
+}
 
-export const textOf = (comment: SourceComment): string => comment.body.join("\n");
+export function textOf(comment: SourceComment): string {
+	return comment.body.join("\n");
+}
 
-export const isJsdoc = (comment: SourceComment): boolean => comment.kind === "block" && comment.text.startsWith("/**") && comment.text !== "/**/";
+export function isJsdoc(comment: SourceComment): boolean {
+	return comment.kind === "block" && comment.text.startsWith("/**") && comment.text !== "/**/";
+}
 
-export const isPragma = (comment: SourceComment, pragmas: readonly string[]): boolean => {
+export function isPragma(comment: SourceComment, pragmas: readonly string[]): boolean {
 	const content = contentOf(comment);
 	return content.length > 0 && content.every((line) => startsWithTag(line, pragmas));
-};
+}
 
-export const isDirective = (comment: SourceComment): boolean => {
+export function isDirective(comment: SourceComment): boolean {
 	const first = contentOf(comment)[0] ?? "";
 	return TRIPLE_SLASH.test(comment.text) || DIRECTIVES.some((directive) => directive.test(first));
-};
+}

package/src/rules/comments/{max-per-file.ts → maxPerFile.ts}

@@ -9,18 +9,22 @@ const MaxPerFileOptions = Schema.Struct({
 	max: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(2)).pipe(Schema.withDecodingDefaultKey(Effect.succeed(2))),
 });
 
-const continues = (previous: SourceComment | undefined, comment: SourceComment): boolean =>
-	previous !== undefined
-	&& previous.kind === "line"
-	&& comment.kind === "line"
-	&& previous.ownLine
-	&& comment.ownLine
-	&& comment.line === previous.endLine + 1;
+function continues(previous: SourceComment | undefined, comment: SourceComment): boolean {
+	return (
+		previous !== undefined
+		&& previous.kind === "line"
+		&& comment.kind === "line"
+		&& previous.ownLine
+		&& comment.ownLine
+		&& comment.line === previous.endLine + 1
+	);
+}
 
-const commentBlocks = (comments: readonly SourceComment[]): readonly SourceComment[] =>
-	comments.filter((comment, index) => !continues(comments[index - 1], comment));
+function commentBlocks(comments: readonly SourceComment[]): readonly SourceComment[] {
+	return comments.filter((comment, index) => !continues(comments[index - 1], comment));
+}
 
-const overCap = (file: SourceFile, max: number, allow: readonly string[]): readonly Finding[] => {
+function overCap(file: SourceFile, max: number, allow: readonly string[]): readonly Finding[] {
 	const counted = commentsOf(file).filter((comment) => !(isDirective(comment) || isPragma(comment, allow)));
 	const blocks = commentBlocks(counted);
 	const first = blocks[max];
@@ -35,7 +39,7 @@ const overCap = (file: SourceFile, max: number, allow: readonly string[]): reado
 					threshold: max,
 				},
 			];
-};
+}
 
 export const maxPerFile = defineRule({
 	check: ({ options, sources }) => sources.flatMap((file) => overCap(file, options.max, options.allow)),

package/src/rules/comments/{no-banner.ts → noBanner.ts}

@@ -1,4 +1,4 @@
-import { definePatternRule } from "./pattern-rule.ts";
+import { definePatternRule } from "./definePattern.ts";
 
 const DIVIDER = "[-=*#~_+/\\\\─━═┄┈]{3,}";
 

package/src/rules/comments/{no-environment-pragma.ts → noEnvironmentPragma.ts}

@@ -1,4 +1,4 @@
-import { definePatternRule } from "./pattern-rule.ts";
+import { definePatternRule } from "./definePattern.ts";
 
 export const noEnvironmentPragma = definePatternRule({
 	description:

package/src/rules/comments/{no-line-reference.ts → noLineReference.ts}

@@ -1,4 +1,4 @@
-import { definePatternRule } from "./pattern-rule.ts";
+import { definePatternRule } from "./definePattern.ts";
 
 const SOURCE_EXTENSION =
 	"(?:[cm]?[jt]sx?|json5?|mdx?|css|scss|less|html?|vue|svelte|astro|ya?ml|toml|sql|prisma|graphql|gql|go|rs|py|rb|java|kt|swift|sh)";

package/src/rules/comments/{no-pr-reference.ts → noPrReference.ts}

@@ -1,4 +1,4 @@
-import { definePatternRule } from "./pattern-rule.ts";
+import { definePatternRule } from "./definePattern.ts";
 
 export const noPrReference = definePatternRule({
 	description: "History belongs in version control, not in the code. State the reason itself, so the comment holds without the link.",

package/src/rules/comments/{no-todo.ts → noTodo.ts}

@@ -1,4 +1,4 @@
-import { definePatternRule } from "./pattern-rule.ts";
+import { definePatternRule } from "./definePattern.ts";
 
 export const noTodo = definePatternRule({
 	description: "A TODO in the code is never done. Do the work now, or track it where the repository tracks work.",

package/src/rules/comments/scan.ts

@@ -13,15 +13,15 @@ export interface SourceComment {
 
 const DECLARATION = /\.d\.[cm]?ts$/u;
 
-const commentRanges = (source: ts.SourceFile): readonly ts.CommentRange[] => {
+function commentRanges(source: ts.SourceFile): readonly ts.CommentRange[] {
 	const ranges = new Map<number, ts.CommentRange>();
 	const jsxText: ts.Node[] = [];
-	const add = (found: readonly ts.CommentRange[] | undefined) => {
+	function add(found: readonly ts.CommentRange[] | undefined) {
 		for (const range of found ?? []) {
 			ranges.set(range.pos, range);
 		}
-	};
-	const visit = (node: ts.Node) => {
+	}
+	function visit(node: ts.Node) {
 		if (node.kind === ts.SyntaxKind.JsxText) {
 			jsxText.push(node);
 		}
@@ -30,22 +30,23 @@ const commentRanges = (source: ts.SourceFile): readonly ts.CommentRange[] => {
 		for (const child of node.getChildren(source)) {
 			visit(child);
 		}
-	};
+	}
 	visit(source);
 	return [...ranges.values()]
 		.filter((range) => !jsxText.some((text) => range.pos >= text.pos && range.pos < text.end))
 		.sort((left, right) => left.pos - right.pos);
-};
+}
 
-export const bodyOf = (kind: SourceComment["kind"], text: string): readonly string[] =>
-	kind === "line"
+export function bodyOf(kind: SourceComment["kind"], text: string): readonly string[] {
+	return kind === "line"
 		? [text.slice(2).trim()]
 		: text
 				.slice(2, -2)
 				.split("\n")
 				.map((line) => line.trim().replace(/^\*(?=\s|$)\s*/u, ""));
+}
 
-const toComment = (source: ts.SourceFile, range: ts.CommentRange): SourceComment => {
+function toComment(source: ts.SourceFile, range: ts.CommentRange): SourceComment {
 	const kind = range.kind === ts.SyntaxKind.SingleLineCommentTrivia ? "line" : "block";
 	const text = source.text.slice(range.pos, range.end);
 	const start = source.getLineAndCharacterOfPosition(range.pos);
@@ -58,16 +59,16 @@ const toComment = (source: ts.SourceFile, range: ts.CommentRange): SourceComment
 		ownLine: source.text.slice(lineStart, range.pos).trim() === "",
 		text,
 	};
-};
+}
 
 const scanned = new WeakMap<SourceFile, readonly SourceComment[]>();
 
-const scan = (file: SourceFile): readonly SourceComment[] => {
+function scan(file: SourceFile): readonly SourceComment[] {
 	const source = parse(file);
 	return source === undefined ? [] : commentRanges(source).map((range) => toComment(source, range));
-};
+}
 
-export const scanComments = (file: SourceFile): readonly SourceComment[] => {
+export function scanComments(file: SourceFile): readonly SourceComment[] {
 	const cached = scanned.get(file);
 	if (cached !== undefined) {
 		return cached;
@@ -75,6 +76,8 @@ export const scanComments = (file: SourceFile): readonly SourceComment[] => {
 	const comments = scan(file);
 	scanned.set(file, comments);
 	return comments;
-};
+}
 
-export const commentsOf = (file: SourceFile): readonly SourceComment[] => (DECLARATION.test(file.path) ? [] : scanComments(file));
+export function commentsOf(file: SourceFile): readonly SourceComment[] {
+	return DECLARATION.test(file.path) ? [] : scanComments(file);
+}

package/src/rules/manifestsSourceFirst.ts

@@ -0,0 +1,48 @@
+import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
+import { Effect } from "effect";
+import { manifestsIn } from "#manifests/sorted.ts";
+import { defineRule, type Finding } from "#rule.ts";
+import { entriesOf, itemsOf, type Json, member, parseJsonc } from "#rules/suppressions/biome/json.ts";
+
+const CONDITION = "source";
+
+function misplaced(path: string, field: string, node: Json): readonly Finding[] {
+	const conditions = entriesOf(node);
+	const first = conditions[0]?.[0];
+	const own: readonly Finding[] =
+		first === CONDITION || !conditions.some(([key]) => key === CONDITION)
+			? []
+			: [
+					{
+						file: path,
+						line: node.line,
+						message: `Lists the "${CONDITION}" condition after "${first}" in ${field}. TypeScript takes the first condition that matches, so once built output exists it reads that instead of the sources the "${CONDITION}" condition names. Move "${CONDITION}" to the top of this condition block.`,
+						subject: field,
+					},
+				];
+	const nested = [...conditions.map(([, value]) => value), ...itemsOf(node)];
+	return [...own, ...nested.flatMap((value) => misplaced(path, field, value))];
+}
+
+function findingsIn(path: string, text: string): readonly Finding[] {
+	const parsed = parseJsonc(path, text);
+	if (parsed._tag !== "Parsed") {
+		return [];
+	}
+	return ["exports", "imports"].flatMap((field) => {
+		const map = member(parsed.json, field);
+		return map === undefined ? [] : misplaced(path, field, map);
+	});
+}
+
+export const manifestsSourceFirst = defineRule({
+	check: async ({ readText, root }) => {
+		const manifests = await Effect.runPromise(manifestsIn(root).pipe(Effect.provide(NodeFileSystem.layer)));
+		const texts = await Promise.all(manifests.map(async (path) => ({ path, text: (await readText(path)) ?? "" })));
+		return texts.filter(({ text }) => text.includes(`"${CONDITION}"`)).flatMap(({ path, text }) => findingsIn(path, text));
+	},
+	description:
+		'Every package.json condition block that names the "source" condition lists it first in exports and imports, so TypeScript reads the sources whether or not built output exists.',
+	id: "manifests/source-first",
+	registrable: false,
+});

package/src/rules/{max-lines.ts → maxLines.ts}

@@ -11,8 +11,8 @@ const MaxLinesOptions = Schema.Struct({
 	test: Limit.check(Schema.isLessThanOrEqualTo(300)).pipe(Schema.withDecodingDefaultKey(Effect.succeed(300))),
 });
 
-const oversized = (file: SourceFile, limit: number): readonly Finding[] =>
-	file.lines.length <= limit
+function oversized(file: SourceFile, limit: number): readonly Finding[] {
+	return file.lines.length <= limit
 		? []
 		: [
 				{
@@ -22,6 +22,7 @@ const oversized = (file: SourceFile, limit: number): readonly Finding[] =>
 					threshold: limit,
 				},
 			];
+}
 
 export const maxLines = defineRule({
 	check: ({ options, sources }) =>

package/src/rules/stories/origins.ts

@@ -0,0 +1,147 @@
+import { join } from "node:path";
+import ts from "typescript";
+import type { ImportGraph } from "#imports/graph.ts";
+import type { RuleInputs } from "#rule.ts";
+import { storyProgram } from "./program.ts";
+
+type Origin = "factory" | "kit" | "story" | "plain" | "suite" | "vitest" | "stories" | "function" | undefined;
+
+function importFrom(node: ts.Node): string | undefined {
+	for (let current: ts.Node | undefined = node; current !== undefined; current = current.parent) {
+		if (ts.isImportDeclaration(current) && ts.isStringLiteral(current.moduleSpecifier)) {
+			return current.moduleSpecifier.text;
+		}
+	}
+	return undefined;
+}
+
+function moduleOrigin(from: string | undefined): Origin {
+	if (from === "vitest" || from === "@effect/vitest") {
+		return "vitest";
+	}
+	return from === "@shivaedev/test-story" || from === "@shivaedev/test-story/storyKit.ts" ? "stories" : undefined;
+}
+
+function imported(name: string, from: string | undefined): Origin {
+	const namespace = moduleOrigin(from);
+	if (name === "storyKit" && namespace === "stories") {
+		return "factory";
+	}
+	if ((name === "describe" || name === "suite") && namespace === "vitest") {
+		return "suite";
+	}
+	return (name === "it" || name === "test") && namespace === "vitest" ? "plain" : undefined;
+}
+
+export function storyOrigins(inputs: RuleInputs, graph: ImportGraph) {
+	const program = storyProgram(inputs, graph);
+	const checker = program.getTypeChecker();
+	const visiting = new Set<ts.Node>();
+	const known = new Map<ts.Node, Origin>();
+
+	function binding(node: ts.BindingElement): Origin {
+		if (!ts.isVariableDeclaration(node.parent.parent)) {
+			return undefined;
+		}
+		const value = node.parent.parent.initializer;
+		const name = node.propertyName ?? node.name;
+		return value !== undefined && (ts.isIdentifier(name) || ts.isStringLiteral(name)) ? member(value, name.text) : undefined;
+	}
+
+	function declaration(node: ts.Node): Origin {
+		if (ts.isImportSpecifier(node)) {
+			return imported((node.propertyName ?? node.name).text, importFrom(node));
+		}
+		if (ts.isNamespaceImport(node)) {
+			return moduleOrigin(importFrom(node));
+		}
+		if (ts.isVariableDeclaration(node) || ts.isPropertyAssignment(node)) {
+			return node.initializer === undefined ? undefined : origin(node.initializer);
+		}
+		return localBinding(node);
+	}
+
+	function localBinding(node: ts.Node): Origin {
+		if (ts.isShorthandPropertyAssignment(node)) {
+			return symbol(checker.getShorthandAssignmentValueSymbol(node));
+		}
+		return ts.isBindingElement(node) ? binding(node) : undefined;
+	}
+
+	function symbol(value: ts.Symbol | undefined): Origin {
+		if (value === undefined) {
+			return undefined;
+		}
+		const direct = value.declarations?.map(visit).find((result) => result !== undefined);
+		return direct ?? (value.flags & ts.SymbolFlags.Alias ? symbol(checker.getAliasedSymbol(value)) : undefined);
+	}
+
+	function object(node: ts.ObjectLiteralExpression): Origin {
+		for (const property of [...node.properties].reverse()) {
+			if (property.name?.getText() === "it") {
+				return visit(property) === "story" ? "kit" : undefined;
+			}
+			if (ts.isSpreadAssignment(property) && visit(property.expression) === "kit") {
+				return "kit";
+			}
+		}
+		return undefined;
+	}
+
+	function member(value: ts.Expression, name: string): Origin {
+		const receiver = visit(value);
+		if (receiver === "kit" && name === "it") {
+			return "story";
+		}
+		if (receiver === "story" || receiver === "plain" || receiver === "suite") {
+			return receiver;
+		}
+		const from = receiver === "vitest" ? "vitest" : undefined;
+		return imported(name, receiver === "stories" ? "@shivaedev/test-story/storyKit.ts" : from);
+	}
+
+	function identifier(node: ts.Identifier): Origin {
+		if (node.text === "describe" || node.text === "suite") {
+			return symbol(checker.getSymbolAtLocation(node)) ?? "suite";
+		}
+		const value = checker.getSymbolAtLocation(node);
+		return symbol(value) ?? (value === undefined && (node.text === "it" || node.text === "test") ? "plain" : undefined);
+	}
+
+	function origin(node: ts.Node): Origin {
+		if (ts.isFunctionLike(node)) {
+			return "function";
+		}
+		if (ts.isObjectLiteralExpression(node)) {
+			return object(node);
+		}
+		return expression(node);
+	}
+
+	function expression(node: ts.Node): Origin {
+		if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isSatisfiesExpression(node)) {
+			return visit(node.expression);
+		}
+		if (ts.isCallExpression(node)) {
+			const callee = visit(node.expression);
+			return callee === "factory" ? "kit" : callee;
+		}
+		if (ts.isPropertyAccessExpression(node)) {
+			return member(node.expression, node.name.text) ?? symbol(checker.getSymbolAtLocation(node.name));
+		}
+		return ts.isIdentifier(node) ? identifier(node) : declaration(node);
+	}
+
+	function visit(node: ts.Node): Origin {
+		if (visiting.has(node) || known.has(node)) {
+			return known.get(node);
+		}
+		visiting.add(node);
+		const result = origin(node);
+		visiting.delete(node);
+		known.set(node, result);
+		return result;
+	}
+
+	return { origin: visit, source: (path: string) => program.getSourceFile(join(inputs.root, path)) };
+}