@antelopejs/interface-core 0.2.4 → 0.2.6

package/docs/4.metadata.md

@@ -4,6 +4,28 @@
 
 The `GetMetadata` function provides a reflection-based metadata system built on top of the `reflect-metadata` library. It retrieves or creates metadata instances associated with target objects, supporting inheritance through the prototype chain.
 
+## Store a value on a target
+
+Give your metadata class a unique symbol, then retrieve its instance for the target. Subsequent calls for that target return the same object; no separate save step is needed.
+
+```ts docs-check
+import { GetMetadata } from "@antelopejs/interface-core";
+
+class LabelMetadata {
+  static key = Symbol("LabelMetadata");
+  label = "";
+  constructor(_target: object) {}
+}
+
+class UserController {}
+const metadata = GetMetadata(UserController.prototype, LabelMetadata);
+metadata.label = "users";
+const same = GetMetadata(UserController.prototype, LabelMetadata);
+// same === metadata; same.label === "users"
+```
+
+Use the constructor or its prototype consistently: they are different targets. The [inheritance example](#inheritance) shows how to copy a parent's collection without sharing mutable state.
+
 ## Import
 
 ```ts
@@ -67,7 +89,7 @@ Calling `GetMetadata` multiple times with the same target and metadata class ret
 
 ## Inheritance
 
-When `inherit` is `true` (the default), `GetMetadata` walks the prototype chain to find parent metadata. If the metadata class defines an `inherit` method, that method is called with the parent metadata. Otherwise, properties from the parent are copied to the child metadata where they do not already exist.
+When first creating metadata and `inherit` is `true` (the default), `GetMetadata` recursively gets or creates metadata on the prototype chain. If the metadata class defines an `inherit` method, that method receives the parent metadata. Otherwise, properties from the parent are copied only where the child has no such key. In particular, an initialized empty child array prevents the default fallback from copying the parent's array.
 
 ```ts
 class ControllerMeta {
@@ -105,6 +127,8 @@ Pass `false` as the third argument to prevent prototype chain traversal:
 const meta = GetMetadata(target, RouteMetadata, false);
 ```
 
+The flag affects creation only. It does not remove inherited values from an instance that was already created, and changing it on a later call does not rebuild the metadata.
+
 ## Next steps
 
 - [Decorators](./3.decorators.md) - Combine metadata with decorator factories

package/docs/5.modules.md

@@ -4,6 +4,21 @@
 
 The `@antelopejs/interface-core/modules` module provides lifecycle events and management functions for AntelopeJS modules. Modules transition through a defined lifecycle, and each transition emits an event that other modules can observe.
 
+## Inspect the running modules
+
+Call these functions from a running AntelopeJS module, where the core has attached their implementations. This example reads status without changing the project.
+
+```ts docs-check
+import { ListModules, GetModuleInfo } from "@antelopejs/interface-core/modules";
+
+for (const id of await ListModules()) {
+  const info = await GetModuleInfo(id);
+  console.log(id, info.status);
+}
+```
+
+Use [management functions](#management-functions) to change what is running now. Use [declaration functions](#declaration-functions) to edit what the project loads on its next start. Neither action automatically performs the other.
+
 ## Import
 
 ```ts
@@ -37,6 +52,8 @@ loaded -> constructed -> active -> constructed -> loaded
 
 ## Module execution context
 
+This is a loader concern. Application modules normally receive their context from the runtime and do not invent their own owner IDs.
+
 `RunWithModuleContext` propagates module ownership through synchronous and asynchronous work:
 
 ```ts
@@ -51,7 +68,7 @@ await RunWithModuleContext(
 );
 ```
 
-`module` remains the stable public module ID. `owner` identifies one lifecycle generation and should be unique when old and replacement instances can overlap. Providers capture this full context when attaching callbacks. `GetModuleContext` returns the active context and throws `ModuleContextInvalidatedError` after its owner is destroyed.
+`module` remains the stable public module ID. `owner` identifies one lifecycle generation and should be unique when old and replacement instances can overlap. `kind` is `"module"` by default; the core sets `"interface"` for the context it evaluates an interface package in. A provider callback runs in the context it was attached in, unless that context is of kind `"interface"`. `GetModuleContext` returns the active context, or `undefined` when there is none, and throws `ModuleContextInvalidatedError` after its owner is destroyed.
 
 ## Lifecycle events
 
@@ -99,7 +116,27 @@ Events.ModuleDestroyed.register((moduleId: string) => {
 });
 ```
 
-The event signature remains the module ID. When emitted inside `RunWithModuleContext`, cleanup targets that context's `owner`; without an explicit owner it retains the module-level behavior used by earlier releases.
+The signature of these four events remains the module ID. When emitted inside `RunWithModuleContext`, cleanup targets that context's `owner`; without an explicit owner it retains the module-level behavior used by earlier releases.
+
+### `Events.ModulesStarted`
+
+Fires once every module the core was asked to start has started: the project as a whole is ready to serve. It does not fire when a module fails to start.
+
+```ts
+Events.ModulesStarted.register(() => {
+  console.log("All modules started");
+});
+```
+
+### `Events.ModulesStopping`
+
+Fires before the first module stops, once per stop following `ModulesStarted`: stopping a project, or reloading one module, is a single "stopping".
+
+```ts
+Events.ModulesStopping.register(() => {
+  console.log("Modules are stopping");
+});
+```
 
 ## Management functions
 

package/docs/6.logging.md

@@ -2,14 +2,25 @@
 
 ## Overview
 
-The `@antelopejs/interface-core/logging` module provides a structured logging system with multiple severity levels and named channels. Log entries are emitted as events through an `EventProxy`, allowing any part of the application to listen for and process log output.
+Use `Logging.Info` for a status message, or a named channel when you want to distinguish one part of the application. These calls emit structured events. The runtime's listener decides how to display them; the interface does not itself write a file or send logs to a service.
 
-## Import
+## Write your first message
 
-```ts
+```ts docs-check
 import { Logging } from "@antelopejs/interface-core/logging";
+
+Logging.Info("Worker started");
+
+const jobs = new Logging.Channel("jobs");
+jobs.Info("Job completed", { jobId: "job-42", durationMs: 120 });
 ```
 
+The first event uses channel `main`; the second uses `jobs`. Both have level `INFO` (`20`). Inside an AntelopeJS project, the runtime's logging configuration determines whether they appear in the output. Without a registered listener, events are not retained for later display.
+
+Log identifiers and outcomes rather than credentials, tokens, or complete request bodies. Arguments reach listeners unchanged; this interface does not redact secrets or serialize arbitrary objects for you.
+
+For ordinary application code, the level and channel methods below are enough. [Custom listeners](#listen-for-log-events) are for integrations that need their own output destination or formatting.
+
 ## Severity levels
 
 The `Logging.Level` enum defines the available severity levels:
@@ -30,10 +41,10 @@ The `Logging` namespace exposes convenience functions that write to the `"main"`
 ```ts
 import { Logging } from "@antelopejs/interface-core/logging";
 
-Logging.Error("Database connection failed", error);
-Logging.Warn("Cache miss for key:", cacheKey);
-Logging.Info("Server started on port", port);
-Logging.Debug("Request payload:", payload);
+Logging.Error("Database connection failed");
+Logging.Warn("Retrying database connection");
+Logging.Info("Server started on port", 5011);
+Logging.Debug("Request completed", { requestId: "req-42", status: 200 });
 Logging.Trace("Entering function processItem");
 ```
 
@@ -49,11 +60,11 @@ import { Logging } from "@antelopejs/interface-core/logging";
 const dbLog = new Logging.Channel("database");
 const httpLog = new Logging.Channel("http");
 
-dbLog.Info("Connected to", dbHost);
-dbLog.Error("Query failed:", query, error);
+dbLog.Info("Connection established");
+dbLog.Error("Query failed", { operation: "listUsers" });
 
-httpLog.Info("GET /api/users", statusCode);
-httpLog.Debug("Response headers:", headers);
+httpLog.Info("GET /api/users", 200);
+httpLog.Debug("Response sent", { requestId: "req-42" });
 ```
 
 Channels provide the same methods as the main logging functions: `Error`, `Warn`, `Info`, `Debug`, and `Trace`.
@@ -86,20 +97,31 @@ interface Log {
 
 ## Listen for log events
 
-The logging system uses an `EventProxy` as its transport. Import the listener to register custom log handlers:
+Register a listener before emitting the messages you want to receive. This example selects warning and error events for console output; it leaves other levels alone.
 
-```ts
-import eventLog from "@antelopejs/interface-core/logging/listener";
+```ts docs-check
+import { Logging } from "@antelopejs/interface-core/logging";
+import eventLog, {
+  type Log,
+} from "@antelopejs/interface-core/logging/listener";
 
-eventLog.register((log) => {
+function writeWarning(log: Log) {
+  if (log.levelId < Logging.Level.WARN) return;
   const date = new Date(log.time).toISOString();
-  const level =
-    log.levelId >= 40 ? "ERROR" : log.levelId >= 30 ? "WARN" : "INFO";
-  console.log(`[${date}] [${level}] [${log.channel}]`, ...log.args);
-});
+  console.warn(`[${date}] [${log.levelId}] [${log.channel}]`, ...log.args);
+}
+
+eventLog.register(writeWarning);
+Logging.Warn("Retry scheduled");
+// When this subscription is no longer needed:
+eventLog.unregister(writeWarning);
 ```
 
-The listener is module-aware. Handlers registered by a module are automatically removed when that module is unloaded.
+Keep the same function reference to unsubscribe. The runtime also removes module-owned listeners when their owner is destroyed. A second console listener may duplicate output already written by the runtime.
+
+Listeners run synchronously. A slow listener delays the logging call, and `emit` does not await promises from asynchronous listeners. Handle asynchronous failures inside your listener. Do not call `Logging.*` from a log listener: that emits another log event and can recurse indefinitely.
+
+Project logging filters belong to the runtime's output listener. A custom listener receives raw events and must apply its own filtering and redaction. `NO_PREFIX` is a level convention for formatters, not a bypass for these responsibilities.
 
 ## Next steps
 

package/docs/7.configuration.md

@@ -4,6 +4,25 @@
 
 The `@antelopejs/interface-core/config` module exports TypeScript types and the `defineConfig` helper for defining AntelopeJS project configurations. These types describe module sources, logging settings, environment overrides, and test configurations.
 
+## Start with one local module
+
+Put this in `antelope.config.ts`, replacing the source path with your module's directory. The module itself must already exist; `defineConfig` does not generate it.
+
+```ts docs-check
+import { defineConfig } from "@antelopejs/interface-core/config";
+
+export default defineConfig({
+  name: "my-project",
+  modules: {
+    app: {
+      source: { type: "local", path: "./modules/app" },
+    },
+  },
+});
+```
+
+`defineConfig` returns its input unchanged. It supplies TypeScript checking, not runtime validation or module loading. Use the source and field reference below as you add modules; config variables and provider overrides are optional advanced features.
+
 ## Import
 
 ```ts
@@ -39,7 +58,7 @@ export default defineConfig({
         package: "@antelopejs/auth",
         version: "1.0.0",
       },
-      config: { secret: "my-secret" },
+      // Supply provider-specific configuration through your deployment's secret handling.
     },
   },
 });
@@ -70,15 +89,15 @@ export default defineConfig((ctx) => {
 
 The root configuration object for an AntelopeJS project.
 
-| Property       | Type                                             | Description                               |
-| -------------- | ------------------------------------------------ | ----------------------------------------- |
-| `name`         | `string`                                         | Project name                              |
-| `cacheFolder`  | `string`                                         | Optional custom cache directory           |
-| `modules`      | `Record<string, string \| AntelopeModuleConfig>` | Module definitions (shorthand or full)    |
-| `logging`      | `AntelopeLogging`                                | Optional logging configuration            |
-| `envOverrides` | `Record<string, string \| string[]>`             | Optional environment variable overrides   |
-| `environments` | `Record<string, Partial<AntelopeConfig>>`        | Optional per-environment config overrides |
-| `test`         | `AntelopeTestConfig`                             | Optional test configuration               |
+| Property       | Type                                             | Description                                     |
+| -------------- | ------------------------------------------------ | ----------------------------------------------- |
+| `name`         | `string`                                         | Project name                                    |
+| `cacheFolder`  | `string`                                         | Optional custom cache directory                 |
+| `modules`      | `Record<string, string \| AntelopeModuleConfig>` | Optional module definitions (shorthand or full) |
+| `logging`      | `AntelopeLogging`                                | Optional logging configuration                  |
+| `envOverrides` | `Record<string, string \| string[]>`             | Optional environment variable overrides         |
+| `environments` | `Record<string, Partial<AntelopeConfig>>`        | Optional per-environment config overrides       |
+| `test`         | `AntelopeTestConfig`                             | Optional test configuration                     |
 
 ## Module sources
 
@@ -157,7 +176,7 @@ Full module configuration within the project config.
 | Property          | Type                                         | Description                                                                                                                              |
 | ----------------- | -------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
 | `version`         | `string`                                     | Optional version constraint                                                                                                              |
-| `source`          | `ModuleSource*`                              | Source definition (local, git, package, local-folder)                                                                                    |
+| `source`          | `ModuleSource*`                              | Optional source definition (local, git, package, local-folder)                                                                           |
 | `config`          | `unknown`                                    | Optional runtime configuration                                                                                                           |
 | `importOverrides` | `ImportOverride[] \| Record<string, string>` | Optional providers pinned for the interfaces the module uses, and named connections                                                      |
 | `disabledExports` | `string[]`                                   | Optional list of exports to disable                                                                                                      |
@@ -171,7 +190,7 @@ This project-file contract also applies to `SaveModuleDeclaration`. It differs i
 
 ## `AntelopeLogging`
 
-Logging configuration within the project config.
+Logging configuration interpreted by the core runtime. All fields are optional. These settings configure the runtime's output; they do not change the raw events sent to a [custom logging listener](./6.logging.md#listen-for-log-events).
 
 | Property         | Type                               | Description                                       |
 | ---------------- | ---------------------------------- | ------------------------------------------------- |

package/docs/8.runtime.md

@@ -4,6 +4,21 @@
 
 The `@antelopejs/interface-core/runtime` module exposes information about the runtime environment of the running project and a registry for development servers. The implementation is provided by the AntelopeJS core: `ajs project dev` reports development mode, while `ajs project start` and `ajs project run` report production mode.
 
+## Check the current mode
+
+Use this inside a running module when behavior genuinely depends on development mode. The selected configuration environment (`env`) is separate from the command's development mode (`dev`).
+
+```ts docs-check
+import { GetRuntimeInfo } from "@antelopejs/interface-core/runtime";
+
+const { dev, env } = await GetRuntimeInfo();
+if (dev) {
+  console.log(`Development helpers enabled for environment ${env}`);
+}
+```
+
+Most consumers need only `GetRuntimeInfo`. The server registry below is for modules that open listening ports and tooling that discovers them; registering an endpoint does not start a server.
+
 ## Import
 
 ```ts

package/docs/assets/proxy-lifecycles.svg

@@ -0,0 +1,21 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 480 438" role="img" aria-labelledby="title desc">
+  <title id="title">Three proxy lifecycles</title>
+  <desc id="desc">Async proxies queue calls until attachment. Event proxies notify current listeners without replay. Registering proxies retain entries and replay them to replacement providers.</desc>
+  <rect width="480" height="438" rx="16" fill="#f5f7fb"/>
+  <g font-family="system-ui, sans-serif" fill="#172b45">
+    <text x="24" y="36" font-size="20" font-weight="700">What survives a missing attachment?</text>
+    <rect x="24" y="58" width="432" height="102" rx="10" fill="#e1ecfa"/>
+    <text x="42" y="88" font-size="18" font-weight="700">AsyncProxy · ask for a result</text>
+    <text x="42" y="119" font-size="16">Call → bounded queue → provider attaches</text>
+    <text x="42" y="144" font-size="16">Pending calls run and resolve or reject.</text>
+    <rect x="24" y="178" width="432" height="102" rx="10" fill="#eee6fb"/>
+    <text x="42" y="208" font-size="18" font-weight="700">EventProxy · notify now</text>
+    <text x="42" y="239" font-size="16">Emit → current listeners</text>
+    <text x="42" y="264" font-size="16">No queue. New listeners do not receive history.</text>
+    <rect x="24" y="298" width="432" height="102" rx="10" fill="#d9eee8"/>
+    <text x="42" y="328" font-size="18" font-weight="700">RegisteringProxy · retain declarations</text>
+    <text x="42" y="359" font-size="16">Register → stored entry → attach → replay</text>
+    <text x="42" y="384" font-size="16">Provider replacement can replay entries again.</text>
+    <text x="24" y="424" font-size="13">Normal runtime behavior; test stub mode rejects missing providers.</text>
+  </g>
+</svg>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antelopejs/interface-core",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "AntelopeJS core interface primitives: proxies, interface functions, decorators, module lifecycle, logging and configuration",
   "keywords": [
     "antelopejs",

package/skills/core-interface/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: core-interface
-description: Provides the AntelopeJS core interface primitives - AsyncProxy/EventProxy/RegisteringProxy, InterfaceFunction, ImplementInterface, GetMetadata, decorator factories, module lifecycle events, structured Logging, and defineConfig. Use when importing from "@antelopejs/interface-core" (or its /decorators, /modules, /proxies, /runtime, /config, /logging subpaths), when declaring or implementing an AntelopeJS interface, wiring cross-module calls or events, building custom decorators, subscribing to ModuleStarted/ModuleDestroyed, writing logs via Logging.Info/Error, or authoring antelope.config with defineConfig.
+description: Provides the AntelopeJS core interface primitives - AsyncProxy/EventProxy/RegisteringProxy, InterfaceFunction, ImplementInterface, GetMetadata, decorator factories, module lifecycle events, structured Logging, and defineConfig. Use when importing from "@antelopejs/interface-core" (or its /decorators, /modules, /proxies, /runtime, /config, /logging subpaths), when declaring or implementing an AntelopeJS interface, wiring cross-module calls or events, building custom decorators, subscribing to ModuleStarted/ModuleDestroyed or ModulesStarted/ModulesStopping, writing logs via Logging.Info/Error, or authoring antelope.config with defineConfig.
 category: antelopejs-interface
 tags: [antelopejs, interface, proxy, decorators, logging]
 ---
@@ -114,10 +114,9 @@ ch.Debug("query", { ms: 12 });
   implementation in test environment. Ensure the required module is loaded in your test config.".
 - Prefer the synchronous `ImplementInterface(decl, impl)`; the Promise-accepting overload is
   deprecated. Implementations may be partial - unmatched keys keep queuing.
-- Module attribution (`GetResponsibleModule`) works by call-stack analysis. Attach implementations
-  and register handlers synchronously during module load; doing it from a setTimeout/setInterval
-  callback logs "this will break hot reloading!", and other async contexts break attribution
-  silently - both defeat automatic cleanup on module unload.
+- Module attribution (`GetResponsibleModule`) reads the async module context the core enters for
+  each module. Provider callbacks run in the provider's context and event handlers in their
+  registrant's; a function passed as an argument runs in whichever context invokes it.
 - `RegisteringProxy` replays existing registrations to a newly attached provider (hot reload safe);
   `EventProxy.register` deduplicates by function identity; both auto-clean handlers of destroyed
   modules via `Events.ModuleDestroyed`.

package/dist/caller-binding.d.ts

@@ -1,12 +0,0 @@
-/**
- * Binds the functions a caller hands to an interface proxy to the caller's
- * module context, so they run as the caller's work whoever invokes them.
- *
- * Functions, and functions held in plain objects and arrays, are bound; plain
- * data, classes, class instances and proxies cross unchanged, so a class keeps
- * the identity its metadata and registries are keyed by. A value is bound once per
- * context, and a value that is already bound keeps its original context.
- */
-export declare function bindCallerArguments<T extends unknown[]>(args: T): T;
-/** Binds a single caller function to the caller's module context. */
-export declare function bindCallerFunction<T extends (...args: any[]) => unknown>(callback: T): T;

package/dist/caller-binding.js

@@ -1,105 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bindCallerArguments = bindCallerArguments;
-exports.bindCallerFunction = bindCallerFunction;
-const node_util_1 = require("node:util");
-const internal_1 = require("./internal");
-const bindingsBySource = new WeakMap();
-const boundValues = new WeakSet();
-const CLASS_SOURCE = /^class\b/;
-function isClass(value) {
-    return CLASS_SOURCE.test(Function.prototype.toString.call(value));
-}
-function isBindableFunction(value) {
-    return typeof value === "function" && !isClass(value);
-}
-function hasPlainPrototype(value) {
-    if (Array.isArray(value)) {
-        return true;
-    }
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-}
-function isBindableContainer(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        !node_util_1.types.isProxy(value) &&
-        hasPlainPrototype(value));
-}
-function holdsFunction(value, visited) {
-    if (isBindableFunction(value)) {
-        return true;
-    }
-    if (!isBindableContainer(value) || visited.has(value)) {
-        return false;
-    }
-    visited.add(value);
-    return Object.values(value).some((member) => holdsFunction(member, visited));
-}
-function needsBinding(value) {
-    if (typeof value === "function") {
-        return isBindableFunction(value) && !boundValues.has(value);
-    }
-    return (isBindableContainer(value) &&
-        !boundValues.has(value) &&
-        holdsFunction(value, new Set()));
-}
-function createFunctionBinding(target, context) {
-    return new Proxy(target, {
-        apply: (callable, thisArg, argumentsList) => (0, internal_1.runWithCapturedModuleContext)(context, () => callable.apply(thisArg, argumentsList)),
-        construct: (callable, argumentsList, newTarget) => (0, internal_1.runWithCapturedModuleContext)(context, () => Reflect.construct(callable, argumentsList, newTarget)),
-    });
-}
-function createContainerBinding(target, context) {
-    return new Proxy(target, {
-        get: (container, property) => {
-            const member = container[property];
-            const descriptor = Reflect.getOwnPropertyDescriptor(container, property);
-            const isFixed = descriptor !== undefined &&
-                !descriptor.configurable &&
-                "value" in descriptor &&
-                !descriptor.writable;
-            return isFixed ? member : bindValue(member, context);
-        },
-    });
-}
-function bindValue(value, context) {
-    if (!needsBinding(value)) {
-        return value;
-    }
-    const cached = bindingsBySource.get(value)?.get(context);
-    if (cached) {
-        return cached;
-    }
-    const bound = typeof value === "function"
-        ? createFunctionBinding(value, context)
-        : createContainerBinding(value, context);
-    const contexts = bindingsBySource.get(value) ??
-        new WeakMap();
-    contexts.set(context, bound);
-    bindingsBySource.set(value, contexts);
-    boundValues.add(bound);
-    return bound;
-}
-/**
- * Binds the functions a caller hands to an interface proxy to the caller's
- * module context, so they run as the caller's work whoever invokes them.
- *
- * Functions, and functions held in plain objects and arrays, are bound; plain
- * data, classes, class instances and proxies cross unchanged, so a class keeps
- * the identity its metadata and registries are keyed by. A value is bound once per
- * context, and a value that is already bound keeps its original context.
- */
-function bindCallerArguments(args) {
-    const context = (0, internal_1.captureModuleContext)();
-    if (!context) {
-        return args;
-    }
-    return args.map((argument) => bindValue(argument, context));
-}
-/** Binds a single caller function to the caller's module context. */
-function bindCallerFunction(callback) {
-    const context = (0, internal_1.captureModuleContext)();
-    return context ? bindValue(callback, context) : callback;
-}
-//# sourceMappingURL=caller-binding.js.map

package/dist/caller-binding.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"caller-binding.js","sourceRoot":"","sources":["../src/caller-binding.ts"],"names":[],"mappings":"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"}

package/dist/responsible-module.d.ts

@@ -1,23 +0,0 @@
-export interface ModuleFolderEntry {
-    dir: string;
-    id: string;
-    isImplementor?: boolean;
-}
-export interface ResponsibleModuleResult {
-    module?: string;
-    lastInterface: string;
-}
-/**
- * Walk the trace to decide which module is responsible for the current call.
- *
- * Rules:
- *   1. `node_modules` and generic `node:internal/` frames are skipped.
- *   2. `node:internal/modules/...` (the require loader) is a hard boundary:
- *      frames above it belong to the module currently being loaded (owning
- *      the side effect); frames below it belong to whoever triggered the
- *      require and must not be credited.
- *   3. The first non-implementor match wins — that is user code. If only
- *      implementor modules match, the first implementor is used as a
- *      fallback so framework-level registrations still have an owner.
- */
-export declare function findResponsibleFile(trace: NodeJS.CallSite[], entries?: ModuleFolderEntry[]): ResponsibleModuleResult;

package/dist/responsible-module.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findResponsibleFile = findResponsibleFile;
-const internal_1 = require("./internal");
-function findMatchingEntry(fileName, entries) {
-    let best;
-    let bestLen = 0;
-    for (const entry of entries) {
-        if (fileName.startsWith(entry.dir) && entry.dir.length > bestLen) {
-            best = entry;
-            bestLen = entry.dir.length;
-        }
-    }
-    return best;
-}
-/**
- * Walk the trace to decide which module is responsible for the current call.
- *
- * Rules:
- *   1. `node_modules` and generic `node:internal/` frames are skipped.
- *   2. `node:internal/modules/...` (the require loader) is a hard boundary:
- *      frames above it belong to the module currently being loaded (owning
- *      the side effect); frames below it belong to whoever triggered the
- *      require and must not be credited.
- *   3. The first non-implementor match wins — that is user code. If only
- *      implementor modules match, the first implementor is used as a
- *      fallback so framework-level registrations still have an owner.
- */
-function findResponsibleFile(trace, entries = internal_1.internal.moduleByFolder) {
-    const lastInterface = "";
-    let implementorMatch;
-    for (const site of trace) {
-        const fileName = site.getFileName();
-        if (fileName?.startsWith("node:internal/modules/")) {
-            break;
-        }
-        if (!fileName ||
-            fileName.startsWith("node:internal/") ||
-            fileName.match(/[/\\]node_modules[/\\]/)) {
-            continue;
-        }
-        const match = findMatchingEntry(fileName, entries);
-        if (!match) {
-            continue;
-        }
-        if (!match.isImplementor) {
-            return { module: match.id, lastInterface };
-        }
-        implementorMatch = match.id;
-    }
-    if (implementorMatch) {
-        return { module: implementorMatch, lastInterface };
-    }
-    return { lastInterface };
-}
-//# sourceMappingURL=responsible-module.js.map

package/dist/responsible-module.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"responsible-module.js","sourceRoot":"","sources":["../src/responsible-module.ts"],"names":[],"mappings":";;AAyCA,kDAiCC;AA1ED,yCAAsC;AAatC,SAAS,iBAAiB,CACxB,QAAgB,EAChB,OAA4B;IAE5B,IAAI,IAAmC,CAAC;IACxC,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,IAAI,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,MAAM,GAAG,OAAO,EAAE,CAAC;YACjE,IAAI,GAAG,KAAK,CAAC;YACb,OAAO,GAAG,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC;QAC7B,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,mBAAmB,CACjC,KAAwB,EACxB,UAA+B,mBAAQ,CAAC,cAAc;IAEtD,MAAM,aAAa,GAAG,EAAE,CAAC;IACzB,IAAI,gBAAoC,CAAC;IAEzC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QACpC,IAAI,QAAQ,EAAE,UAAU,CAAC,wBAAwB,CAAC,EAAE,CAAC;YACnD,MAAM;QACR,CAAC;QACD,IACE,CAAC,QAAQ;YACT,QAAQ,CAAC,UAAU,CAAC,gBAAgB,CAAC;YACrC,QAAQ,CAAC,KAAK,CAAC,wBAAwB,CAAC,EACxC,CAAC;YACD,SAAS;QACX,CAAC;QACD,MAAM,KAAK,GAAG,iBAAiB,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QACnD,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,SAAS;QACX,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;YACzB,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,EAAE,aAAa,EAAE,CAAC;QAC7C,CAAC;QACD,gBAAgB,GAAG,KAAK,CAAC,EAAE,CAAC;IAC9B,CAAC;IAED,IAAI,gBAAgB,EAAE,CAAC;QACrB,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,aAAa,EAAE,CAAC;IACrD,CAAC;IACD,OAAO,EAAE,aAAa,EAAE,CAAC;AAC3B,CAAC"}