@filipebraida/adonis-function-points 0.1.0 → 0.3.0

package/build/{resolvers-CU9HKYpn.js → resolvers-CRB6lXoo.js}

@@ -1,228 +1,150 @@
-import { Node, SyntaxKind } from "ts-morph";
-//#region src/inventory/resolvers/action_object.ts
+import { Node, Project, SyntaxKind } from "ts-morph";
+//#region src/inventory/paths.ts
 /**
-* "Action object" pattern: the transaction delegates to an action instantiated
-* at the call site.
+* One canonical spelling for every path the inventory emits.
 *
-*     await new ExpireInvite().handle({ invite })
+* Two path styles meet in this package. ts-morph always returns forward
+* slashes, including on Windows; node's `path.join` returns backslashes there.
+* Both end up in `HandlerRef.file`, and the call graph uses that string as a
+* cache key:
 *
-*     const mark = new MarkContentChanged()
-*     await mark.handle({ documentId })
+*     const key = `${ref.file}#${ref.member ?? ref.line ?? '*'}`
 *
-* The second form keeps the instance in a local variable, so the declaration
-* has to be followed back to the `new` — that is what `classOfReceiver` does.
-*/
-const actionObjectResolver = {
-	name: "action-object",
-	order: 10,
-	resolve(call, ctx) {
-		const expr = call.getExpression();
-		if (!expr.isKind(SyntaxKind.PropertyAccessExpression)) return [];
-		const member = expr.getName();
-		const className = classOfReceiver(expr.getExpression());
-		if (!className) return [];
-		const file = ctx.imports.get(className);
-		if (!file) return [];
-		return [{
-			file,
-			member
-		}];
-	}
-};
-/**
-* Finds the class behind a call receiver.
+* Two spellings of the same file are two keys, so the same body would be
+* analysed twice and pushed twice into the trace and the implementation scope
+* — and a repeated scope entry changes the hash `fp:diff` compares.
 *
-*   new Foo().handle()                    -> 'Foo'
-*   foo.handle()  where  const foo = new Foo()  -> 'Foo'
+* Forward slashes win because ts-morph cannot be told otherwise, node's `fs`
+* accepts them on Windows, and `path.relative` normalises mixed input anyway.
+* Normalising at the boundary where a path is created costs one call; leaving
+* it to each comparison costs vigilance forever.
 */
-function classOfReceiver(receiver) {
-	if (receiver.isKind(SyntaxKind.NewExpression)) {
-		const target = receiver.getExpression();
-		return target.isKind(SyntaxKind.Identifier) ? target.getText() : null;
-	}
-	if (receiver.isKind(SyntaxKind.Identifier)) {
-		const init = (receiver.getSymbol()?.getDeclarations().find((d) => d.isKind(SyntaxKind.VariableDeclaration)))?.asKind(SyntaxKind.VariableDeclaration)?.getInitializer();
-		if (init?.isKind(SyntaxKind.NewExpression)) {
-			const target = init.getExpression();
-			return target.isKind(SyntaxKind.Identifier) ? target.getText() : null;
-		}
+const toPosix = (value) => value.split("\\").join("/");
+/** Compares two paths that may have come from different sources. */
+const samePath = (a, b) => a !== void 0 && b !== void 0 && toPosix(a) === toPosix(b);
+//#endregion
+//#region src/inventory/sources/event_bindings.ts
+/** the method a listener declares; AdonisJS calls `handle` unless told otherwise */
+const LISTENER_METHOD = "handle";
+function collectEventBindings(app) {
+	const project = new Project({
+		skipAddingFilesFromTsConfig: true,
+		skipFileDependencyResolution: true,
+		compilerOptions: { allowJs: false }
+	});
+	for (const root of app.scanRoots) project.addSourceFilesAtPaths(`${root}/**/*.ts`);
+	const bindings = /* @__PURE__ */ new Map();
+	for (const file of project.getSourceFiles()) for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+		const expression = call.getExpression();
+		if (!Node.isPropertyAccessExpression(expression)) continue;
+		if (expression.getName() !== "on") continue;
+		const [event, handlers] = call.getArguments();
+		if (!event || !handlers) continue;
+		const eventFile = resolveEventClass(event, file, app);
+		if (!eventFile) continue;
+		const refs = listenersOf(handlers, file, app);
+		if (refs.length === 0) continue;
+		bindings.set(eventFile, [...bindings.get(eventFile) ?? [], ...refs]);
 	}
-	return null;
+	return bindings;
 }
-//#endregion
-//#region src/inventory/resolvers/job_dispatch.ts
-const DISPATCH_METHODS = new Set([
-	"dispatch",
-	"dispatchLater",
-	"enqueue",
-	"later"
-]);
 /**
-* "Job" pattern: the write happens asynchronously.
-*
-*     await CreateUserJob.dispatch({ userId })
-*
-* Runs before `static-service` on purpose: the syntactic shape is identical
-* (`Identifier.method(args)`) and the generic strategy would swallow the job.
-* The distinction is semantic, and it matters because the counting decision
-* differs.
+* The event class a dispatch or a binding names.
 *
-* COUNTING DECISION: a job dispatched by a handler is followed as part of the
-* SAME transactional function, because IFPUG counts what the user recognises —
-* they click and the effect happens, even if execution is asynchronous. A
-* SCHEDULED job, which nobody dispatches, is a different thing: it is an entry
-* point of its own, and out of v1 scope — only HTTP routes are collected.
+* Two shapes reach here: the class imported directly, and the generated
+* registry (`events.OrderPlaced`), which is what `node ace make:event` produces
+* and therefore the common one. Exported because the resolver has to ask the
+* same question of a call site, and two implementations of "which event is
+* this" would drift.
 */
-const jobDispatchResolver = {
-	name: "job-dispatch",
-	order: 15,
-	resolve(call, ctx) {
-		const expr = call.getExpression();
-		if (!expr.isKind(SyntaxKind.PropertyAccessExpression)) return [];
-		if (!DISPATCH_METHODS.has(expr.getName())) return [];
-		const receiver = expr.getExpression();
-		if (!receiver.isKind(SyntaxKind.Identifier)) return [];
-		const symbol = receiver.getText();
-		if (ctx.dataStoresBySymbol.has(symbol)) return [];
-		const file = ctx.imports.get(symbol);
-		if (!file) return [];
-		return [{
-			file,
-			member: ctx.sourceFile(file)?.getClasses().some((c) => c.getMethod("handle")) ? "handle" : expr.getName()
-		}];
+function resolveEventClass(expression, from, app) {
+	if (Node.isIdentifier(expression)) {
+		const target = importedFrom(expression.getText(), from, app);
+		return target ? toPosix(target) : null;
 	}
-};
-//#endregion
-//#region src/inventory/resolvers/module_function.ts
-/**
-* "Module function" pattern: no class at all.
-*
-*     await createUser(payload)
-*     await syncWithProvider(order)
-*
-* Runs last: it matches any call to an imported identifier and would otherwise
-* swallow the more precise patterns.
-*/
-const moduleFunctionResolver = {
-	name: "module-function",
-	order: 50,
-	resolve(call, ctx) {
-		const expr = call.getExpression();
-		if (!expr.isKind(SyntaxKind.Identifier)) return [];
-		const file = ctx.imports.get(expr.getText());
-		if (!file) return [];
-		return [{
+	if (!Node.isPropertyAccessExpression(expression)) return null;
+	const root = expression.getExpression();
+	if (!Node.isIdentifier(root)) return null;
+	const registry = importedFrom(root.getText(), from, app);
+	if (!registry) return null;
+	return registryEntry(registry, expression.getName(), from.getProject(), app);
+}
+/** listener bodies named by the second argument of `emitter.on` */
+function listenersOf(handlers, from, app) {
+	const entries = handlers.isKind(SyntaxKind.ArrayLiteralExpression) ? handlers.getElements() : [handlers];
+	const refs = [];
+	for (const entry of entries) {
+		/**
+		* `[SomeListener, 'method']`: AdonisJS lets the binding name the method,
+		* and taking `handle` on faith there would look for a body that is not
+		* the one bound.
+		*/
+		if (entry.isKind(SyntaxKind.ArrayLiteralExpression)) {
+			const [target, member] = entry.getElements();
+			const file = target ? listenerFile(target, from, app) : null;
+			if (!file) continue;
+			const named = member?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+			refs.push({
+				file,
+				member: named ?? LISTENER_METHOD
+			});
+			continue;
+		}
+		const file = listenerFile(entry, from, app);
+		if (file) refs.push({
 			file,
-			member: expr.getText()
-		}];
+			member: LISTENER_METHOD
+		});
 	}
-};
-//#endregion
-//#region src/inventory/resolvers/property_service.ts
-/**
-* "Injected dependency" pattern: the call leaves through a class property.
-*
-*     @inject()
-*     class InvoiceController {
-*       constructor(protected billing: BillingService) {}
-*       async queue() { await this.billing.enqueue(invoice) }
-*     }
-*
-* This is the official AdonisJS pattern, and in applications that use it, it is
-* frequently the only path from a route down to a write.
-*
-* **No type checker required.** `@inject()` only works with an explicit type
-* annotation — that annotation is how the container knows what to inject — so
-* the type is always in the AST as an imported identifier.
-*/
-const propertyServiceResolver = {
-	name: "property-service",
-	order: 30,
-	resolve(call, ctx) {
-		const expression = call.getExpression();
-		if (!Node.isPropertyAccessExpression(expression)) return [];
-		const receiver = expression.getExpression();
-		if (!Node.isPropertyAccessExpression(receiver)) return [];
-		if (receiver.getExpression().getKind() !== SyntaxKind.ThisKeyword) return [];
-		const file = ctx.injected.get(receiver.getName());
-		if (!file) return [];
-		return [{
-			file,
-			member: expression.getName()
-		}];
+	return refs;
+}
+function listenerFile(entry, from, app) {
+	if (Node.isPropertyAccessExpression(entry)) {
+		const root = entry.getExpression();
+		if (!Node.isIdentifier(root)) return null;
+		const registry = importedFrom(root.getText(), from, app);
+		return registry ? registryEntry(registry, entry.getName(), from.getProject(), app) : null;
 	}
-};
-//#endregion
-//#region src/inventory/resolvers/same_class_method.ts
-/**
-* "Same class method" pattern: `this.privateMethod()`.
-*
-*     async expire(uuid: string) {
-*       const invite = await this.findByUuid(uuid)
-*       await this.persistExpiration(invite)
-*     }
-*
-* A public method delegating to private ones of the same class is where writes
-* often live. No other strategy covers it — `property-service` requires
-* `this.dependency.method()`, with two levels of access.
-*
-* Runs before `property-service` because it is more specific: the receiver is
-* exactly `this`.
-*/
-const sameClassMethodResolver = {
-	name: "same-class-method",
-	order: 5,
-	resolve(call, ctx) {
-		const expression = call.getExpression();
-		if (!Node.isPropertyAccessExpression(expression)) return [];
-		if (expression.getExpression().getKind() !== SyntaxKind.ThisKeyword) return [];
-		const member = expression.getName();
-		const owner = call.getFirstAncestorByKind(SyntaxKind.ClassDeclaration);
-		if (!owner) return [];
-		/**
-		* Only claim the call if the method really exists on the class. Otherwise
-		* `this.someFunctionProperty()` would be claimed, the body lookup would
-		* fail, and the report would blame inheritance from a package — sending the
-		* reader to the wrong place.
-		*/
-		if (!owner.getMethod(member) && !owner.getStaticMethod(member)) return [];
-		return [{
-			file: ctx.file.getFilePath(),
-			member
-		}];
+	if (Node.isIdentifier(entry)) {
+		const target = importedFrom(entry.getText(), from, app);
+		return target ? toPosix(target) : null;
 	}
-};
-//#endregion
-//#region src/inventory/resolvers/static_service.ts
+	return null;
+}
+/** where a local identifier was imported from, resolved through the alias map */
+function importedFrom(local, from, app) {
+	for (const declaration of from.getImportDeclarations()) {
+		const named = declaration.getNamedImports().some((entry) => (entry.getAliasNode()?.getText() ?? entry.getName()) === local);
+		const isDefault = declaration.getDefaultImport()?.getText() === local;
+		if (!named && !isDefault) continue;
+		return app.resolveSpecifier(declaration.getModuleSpecifierValue());
+	}
+	return null;
+}
 /**
-* "Static service" pattern: a class method called without instantiating.
+* The file a key of a generated registry points at.
 *
-*     await UserService.create(payload)
-*     await OrderService.finalize(order)
-*
-* Careful: `Order.findByOrFail(...)` has exactly the same syntactic shape. The
-* difference is semantic — a model is a data store, not a body to walk into,
-* and the persistence detector handles it. Hence this resolver depends on
-* `ctx.dataStoresBySymbol` already being populated.
+* Both shapes the generators emit are handled: a direct reference to an
+* imported class (`events.ts`) and a lazy importer (`listeners.ts`). They differ
+* per artefact and per framework version, and reading only one of them silently
+* lost half the graph.
 */
-const staticServiceResolver = {
-	name: "static-service",
-	order: 20,
-	resolve(call, ctx) {
-		const expr = call.getExpression();
-		if (!expr.isKind(SyntaxKind.PropertyAccessExpression)) return [];
-		const receiver = expr.getExpression();
-		if (!receiver.isKind(SyntaxKind.Identifier)) return [];
-		const symbol = receiver.getText();
-		if (ctx.dataStoresBySymbol.has(symbol)) return [];
-		const file = ctx.imports.get(symbol);
-		if (!file) return [];
-		return [{
-			file,
-			member: expr.getName()
-		}];
+function registryEntry(registryFile, key, project, app) {
+	const file = project.getSourceFile(registryFile) ?? project.addSourceFileAtPathIfExists(registryFile);
+	if (!file) return null;
+	for (const declaration of file.getVariableDeclarations()) {
+		const value = ((declaration.getInitializer()?.asKind(SyntaxKind.ObjectLiteralExpression))?.getProperty(key)?.asKind(SyntaxKind.PropertyAssignment))?.getInitializer();
+		if (!value) continue;
+		if (Node.isIdentifier(value)) {
+			const target = importedFrom(value.getText(), file, app);
+			return target ? toPosix(target) : null;
+		}
+		const specifier = value.getFirstDescendantByKind(SyntaxKind.CallExpression)?.getArguments()[0]?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+		const target = specifier ? app.resolveSpecifier(specifier) : null;
+		return target ? toPosix(target) : null;
 	}
-};
+	return null;
+}
 //#endregion
 //#region src/inventory/detectors/lucid.ts
 const WRITE_METHODS = new Set([
@@ -360,16 +282,56 @@ function detectAccess(call, symbols, relations = /* @__PURE__ */ new Map()) {
 	*/
 	const store = symbols.get(pathSymbolOf(receiver) ?? "") ?? symbols.get(rootSymbolOf(receiver) ?? "");
 	if (!store) return null;
+	/**
+	* `distribution.related('files').create({…})` — the relation is the SUBJECT of
+	* the write, not a table read along the way.
+	*
+	* `relationTargetOf` reads the current method, and here the current method is
+	* `create`, whose receiver is the `related(…)` call. Without looking back up the
+	* chain the write was attributed to `distributions` alone and `distribution_files`
+	* came out as a table this application only reads — an EIF, maintained by
+	* somebody else. That is what a production application reported, and it is
+	* ordinary Lucid: `related(…)` followed by `create`, `createMany`, `save`,
+	* `saveMany`, `attach`, `detach` or `sync` writes the related table.
+	*/
+	const related = relatedCallIn(receiver);
+	const viaRelation = relationTargetOf(method, call, store, relations) ?? (related ? relationTargetOf("related", related, store, relations) : void 0);
 	return {
 		mode: isWrite ? "write" : "read",
 		store,
 		method,
 		line: call.getStartLineNumber(),
-		viaRelation: relationTargetOf(method, call, store, relations),
+		viaRelation,
+		/** the relation is written when the method acting on it writes */
+		relationWritten: isWrite,
 		firesHooks: firesHooks(receiver)
 	};
 }
 /**
+* The `related('x')` call inside a receiver chain, if any.
+*
+* Only `related` qualifies: `preload` and `load` hand back the parent, so a write
+* after them acts on the parent. `related` hands back the relation's own query
+* builder, and that is what makes the difference.
+*/
+function relatedCallIn(receiver) {
+	let current = receiver;
+	for (let depth = 0; depth < 20 && current; depth++) {
+		if (Node.isCallExpression(current)) {
+			const expression = current.getExpression();
+			if (Node.isPropertyAccessExpression(expression) && expression.getName() === "related") return current;
+			current = expression;
+			continue;
+		}
+		if (Node.isPropertyAccessExpression(current) || Node.isAwaitExpression(current)) {
+			current = current.getExpression();
+			continue;
+		}
+		break;
+	}
+	return null;
+}
+/**
 * An access fires hooks unless it went through the query builder.
 *
 * The signal is a CALL anywhere in the receiver chain: `document.delete()` has
@@ -439,6 +401,301 @@ function rootSymbolOf(node) {
 	return null;
 }
 //#endregion
+//#region src/inventory/resolvers/action_object.ts
+/**
+* "Action object" pattern: the transaction delegates to an action instantiated
+* at the call site.
+*
+*     await new ExpireInvite().handle({ invite })
+*
+*     const mark = new MarkContentChanged()
+*     await mark.handle({ documentId })
+*
+* The second form keeps the instance in a local variable, so the declaration
+* has to be followed back to the `new` — that is what `classOfReceiver` does.
+*/
+const actionObjectResolver = {
+	name: "action-object",
+	order: 10,
+	resolve(call, ctx) {
+		const expr = call.getExpression();
+		if (!expr.isKind(SyntaxKind.PropertyAccessExpression)) return [];
+		const member = expr.getName();
+		const className = classOfReceiver(expr.getExpression());
+		if (!className) return [];
+		const file = ctx.imports.get(className);
+		if (!file) return [];
+		return [{
+			file,
+			member
+		}];
+	}
+};
+/**
+* Finds the class behind a call receiver.
+*
+*   new Foo().handle()                    -> 'Foo'
+*   foo.handle()  where  const foo = new Foo()  -> 'Foo'
+*/
+function classOfReceiver(receiver) {
+	if (receiver.isKind(SyntaxKind.NewExpression)) {
+		const target = receiver.getExpression();
+		return target.isKind(SyntaxKind.Identifier) ? target.getText() : null;
+	}
+	if (receiver.isKind(SyntaxKind.Identifier)) {
+		const init = (receiver.getSymbol()?.getDeclarations().find((d) => d.isKind(SyntaxKind.VariableDeclaration)))?.asKind(SyntaxKind.VariableDeclaration)?.getInitializer();
+		if (init?.isKind(SyntaxKind.NewExpression)) {
+			const target = init.getExpression();
+			return target.isKind(SyntaxKind.Identifier) ? target.getText() : null;
+		}
+	}
+	return null;
+}
+//#endregion
+//#region src/inventory/resolvers/event_dispatch.ts
+/**
+* "Event" pattern: the handler announces, and listeners act.
+*
+*     await events.OrderPlaced.dispatch(order.id)
+*
+* Runs BEFORE `job-dispatch`, which matches `Identifier.dispatch(args)` — the
+* shape the direct form takes. Left to it, the event class was resolved and
+* searched for a `handle` it does not declare (`dispatch` comes from
+* `BaseEvent`), so the call was reported as an unknown and the listeners' reads
+* and writes went uncounted.
+*
+* COUNTING DECISION: the same one taken for a job. The user clicks, the effect
+* happens, and AFP §6.5.3 requires aggregating every path the transaction
+* reaches — the emitter is an implementation detail of how it gets there.
+*/
+const eventDispatchResolver = {
+	name: "event-dispatch",
+	order: 12,
+	resolve(call, ctx) {
+		if (ctx.eventBindings.size === 0) return [];
+		const expression = call.getExpression();
+		if (!expression.isKind(SyntaxKind.PropertyAccessExpression)) return [];
+		if (expression.getName() !== "dispatch") return [];
+		const receiver = expression.getExpression();
+		if (!Node.isIdentifier(receiver) && !Node.isPropertyAccessExpression(receiver)) return [];
+		const eventFile = resolveEventClass(receiver, ctx.file, { resolveSpecifier: ctx.resolveSpecifier });
+		return eventFile ? ctx.eventBindings.get(eventFile) ?? [] : [];
+	}
+};
+//#endregion
+//#region src/inventory/resolvers/job_dispatch.ts
+const DISPATCH_METHODS = new Set([
+	"dispatch",
+	"dispatchMany",
+	"dispatchLater",
+	"enqueue",
+	"later"
+]);
+/**
+* The method that actually runs the job, by queue package.
+*
+* There is no single name, and this list grew twice by measurement rather than by
+* reasoning. `@rlanz/bull-queue` uses `handle`; `@nemoventures/adonis-jobs` calls
+* it `process`; `@adonisjs/queue` — the official package — generates
+* `async execute()` in its own `make:job` stub. Each omission cost the same: the
+* file resolved, no body was found, the dispatch was reported as an unknown, and
+* every write inside the job went uncounted.
+*
+* `execute` surfaced only once event dispatch started being followed, because the
+* listener was what enqueued the job and that path had never been walked. Which is
+* the argument for adding a name when a real application shows it: a list written
+* from imagination would have missed this one too.
+*
+* Ordered: a class declaring more than one is answering the dispatcher with the
+* first, and `handle` is the most common.
+*/
+const EXECUTION_METHODS = [
+	"handle",
+	"execute",
+	"process",
+	"run",
+	"perform"
+];
+/**
+* "Job" pattern: the write happens asynchronously.
+*
+*     await CreateUserJob.dispatch({ userId })
+*
+* Runs before `static-service` on purpose: the syntactic shape is identical
+* (`Identifier.method(args)`) and the generic strategy would swallow the job.
+* The distinction is semantic, and it matters because the counting decision
+* differs.
+*
+* COUNTING DECISION: a job dispatched by a handler is followed as part of the
+* SAME transactional function, because IFPUG counts what the user recognises —
+* they click and the effect happens, even if execution is asynchronous. A
+* SCHEDULED job, which nobody dispatches, is a different thing: it is an entry
+* point of its own, and out of v1 scope — only HTTP routes are collected.
+*/
+const jobDispatchResolver = {
+	name: "job-dispatch",
+	order: 15,
+	resolve(call, ctx) {
+		const expr = call.getExpression();
+		if (!expr.isKind(SyntaxKind.PropertyAccessExpression)) return [];
+		if (!DISPATCH_METHODS.has(expr.getName())) return [];
+		const receiver = expr.getExpression();
+		if (!receiver.isKind(SyntaxKind.Identifier)) return [];
+		const symbol = receiver.getText();
+		if (ctx.dataStoresBySymbol.has(symbol)) return [];
+		const file = ctx.imports.get(symbol);
+		if (!file) return [];
+		/**
+		* `dispatch` enqueues; the execution method is what touches data. When the
+		* class declares one, that is the body that matters — and when it declares
+		* none, the dispatch name is kept so the gap stays visible instead of being
+		* quietly attributed to a body nobody found.
+		*/
+		const classes = ctx.sourceFile(file)?.getClasses() ?? [];
+		return [{
+			file,
+			member: EXECUTION_METHODS.find((name) => classes.some((c) => c.getMethod(name))) ?? expr.getName()
+		}];
+	}
+};
+//#endregion
+//#region src/inventory/resolvers/module_function.ts
+/**
+* "Module function" pattern: no class at all.
+*
+*     await createUser(payload)
+*     await syncWithProvider(order)
+*
+* Runs last: it matches any call to an imported identifier and would otherwise
+* swallow the more precise patterns.
+*/
+const moduleFunctionResolver = {
+	name: "module-function",
+	order: 50,
+	resolve(call, ctx) {
+		const expr = call.getExpression();
+		if (!expr.isKind(SyntaxKind.Identifier)) return [];
+		const local = expr.getText();
+		const file = ctx.imports.get(local);
+		if (!file) return [];
+		/**
+		* The body carries the exported name, not the local one. Following the
+		* local name through an alias finds nothing and reports the call as
+		* unresolved for a reason that is not true.
+		*/
+		return [{
+			file,
+			member: ctx.exportedAs.get(local) ?? local
+		}];
+	}
+};
+//#endregion
+//#region src/inventory/resolvers/property_service.ts
+/**
+* "Injected dependency" pattern: the call leaves through a class property.
+*
+*     @inject()
+*     class InvoiceController {
+*       constructor(protected billing: BillingService) {}
+*       async queue() { await this.billing.enqueue(invoice) }
+*     }
+*
+* This is the official AdonisJS pattern, and in applications that use it, it is
+* frequently the only path from a route down to a write.
+*
+* **No type checker required.** `@inject()` only works with an explicit type
+* annotation — that annotation is how the container knows what to inject — so
+* the type is always in the AST as an imported identifier.
+*/
+const propertyServiceResolver = {
+	name: "property-service",
+	order: 30,
+	resolve(call, ctx) {
+		const expression = call.getExpression();
+		if (!Node.isPropertyAccessExpression(expression)) return [];
+		const receiver = expression.getExpression();
+		if (!Node.isPropertyAccessExpression(receiver)) return [];
+		if (receiver.getExpression().getKind() !== SyntaxKind.ThisKeyword) return [];
+		const file = ctx.injected.get(receiver.getName());
+		if (!file) return [];
+		return [{
+			file,
+			member: expression.getName()
+		}];
+	}
+};
+//#endregion
+//#region src/inventory/resolvers/same_class_method.ts
+/**
+* "Same class method" pattern: `this.privateMethod()`.
+*
+*     async expire(uuid: string) {
+*       const invite = await this.findByUuid(uuid)
+*       await this.persistExpiration(invite)
+*     }
+*
+* A public method delegating to private ones of the same class is where writes
+* often live. No other strategy covers it — `property-service` requires
+* `this.dependency.method()`, with two levels of access.
+*
+* Runs before `property-service` because it is more specific: the receiver is
+* exactly `this`.
+*/
+const sameClassMethodResolver = {
+	name: "same-class-method",
+	order: 5,
+	resolve(call, ctx) {
+		const expression = call.getExpression();
+		if (!Node.isPropertyAccessExpression(expression)) return [];
+		if (expression.getExpression().getKind() !== SyntaxKind.ThisKeyword) return [];
+		const member = expression.getName();
+		const owner = call.getFirstAncestorByKind(SyntaxKind.ClassDeclaration);
+		if (!owner) return [];
+		/**
+		* Only claim the call if the method really exists on the class. Otherwise
+		* `this.someFunctionProperty()` would be claimed, the body lookup would
+		* fail, and the report would blame inheritance from a package — sending the
+		* reader to the wrong place.
+		*/
+		if (!owner.getMethod(member) && !owner.getStaticMethod(member)) return [];
+		return [{
+			file: ctx.file.getFilePath(),
+			member
+		}];
+	}
+};
+//#endregion
+//#region src/inventory/resolvers/static_service.ts
+/**
+* "Static service" pattern: a class method called without instantiating.
+*
+*     await UserService.create(payload)
+*     await OrderService.finalize(order)
+*
+* Careful: `Order.findByOrFail(...)` has exactly the same syntactic shape. The
+* difference is semantic — a model is a data store, not a body to walk into,
+* and the persistence detector handles it. Hence this resolver depends on
+* `ctx.dataStoresBySymbol` already being populated.
+*/
+const staticServiceResolver = {
+	name: "static-service",
+	order: 20,
+	resolve(call, ctx) {
+		const expr = call.getExpression();
+		if (!expr.isKind(SyntaxKind.PropertyAccessExpression)) return [];
+		const receiver = expr.getExpression();
+		if (!receiver.isKind(SyntaxKind.Identifier)) return [];
+		const symbol = receiver.getText();
+		if (ctx.dataStoresBySymbol.has(symbol)) return [];
+		const file = ctx.imports.get(symbol);
+		if (!file) return [];
+		return [{
+			file,
+			member: expr.getName()
+		}];
+	}
+};
+//#endregion
 //#region src/inventory/resolvers/transformer.ts
 /** BaseTransformer's public API; all of it funnels through `toObject` */
 const TRANSFORMER_METHODS = new Set([
@@ -526,6 +783,7 @@ function extendsTransformer(file) {
 const BUILTIN_CALL_RESOLVERS = [
 	sameClassMethodResolver,
 	actionObjectResolver,
+	eventDispatchResolver,
 	jobDispatchResolver,
 	transformerResolver,
 	staticServiceResolver,
@@ -543,6 +801,15 @@ const BUILTIN_CALL_RESOLVERS = [
 */
 function resolveCall(call, ctx, resolvers = BUILTIN_CALL_RESOLVERS) {
 	for (const resolver of resolvers) {
+		/**
+		* Asked before `resolve`, and in the same order: a strategy that claims a
+		* call as data-free must not be overtaken by a later, more generic one
+		* following it into a body it has no business reading.
+		*/
+		if (resolver.ignores?.(call, ctx)) return {
+			by: resolver.name,
+			refs: []
+		};
 		const refs = resolver.resolve(call, ctx);
 		if (refs.length > 0) return {
 			by: resolver.name,
@@ -552,4 +819,4 @@ function resolveCall(call, ctx, resolvers = BUILTIN_CALL_RESOLVERS) {
 	return null;
 }
 //#endregion
-export { rootSymbolOf as a, hooksFiredBy as i, resolveCall as n, detectAccess as r, BUILTIN_CALL_RESOLVERS as t };
+export { rootSymbolOf as a, toPosix as c, hooksFiredBy as i, resolveCall as n, collectEventBindings as o, detectAccess as r, samePath as s, BUILTIN_CALL_RESOLVERS as t };