@antelopejs/interface-core 0.2.3 → 0.2.5

package/docs/3.decorators.md

@@ -2,7 +2,31 @@
 
 ## Overview
 
-The `@antelopejs/interface-core/decorators` module provides factory functions for creating type-safe TypeScript decorators. These factories handle the boilerplate of splitting decorator arguments from factory arguments, producing reusable, parameterized decorators for classes, properties, methods, and parameters.
+Use these factories when you are building a decorator, rather than using an existing one such as `@Get`. Your callback receives the decorated target first and the arguments from the decorator call afterwards.
+
+These are TypeScript legacy decorators: enable `experimentalDecorators`. They do not implement the standard JavaScript decorator context API. Examples that call `Reflect.defineMetadata` also need `import "reflect-metadata"` before use; importing the package root already loads it.
+
+Start with [`MakeClassDecorator`](#makeclassdecorator) for a one-target example. Consult the combined factory table only when the same decorator must support several targets.
+
+## Name a class with a decorator
+
+This decorator stores a label when the class is declared. `target` is the class constructor; `name` is the value passed to `@Label`.
+
+```ts docs-check
+import { MakeClassDecorator } from "@antelopejs/interface-core/decorators";
+
+const labels = new WeakMap<Function, string>();
+const Label = MakeClassDecorator((target: Function, name: string) => {
+  labels.set(target, name);
+});
+
+@Label("users")
+class UserController {}
+
+const label = labels.get(UserController); // "users"
+```
+
+The factories do not run request-time behavior by themselves. Your integration decides when to read stored values or invoke a decorated method.
 
 ## Import
 

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
 
@@ -209,12 +226,14 @@ await RemoveModuleDeclaration("@acme/reports");
 
 The configuration object for defining a module.
 
-| Property          | Type                             | Description                                       |
-| ----------------- | -------------------------------- | ------------------------------------------------- |
-| `source`          | `{ type: string } & Record<...>` | Source location and loading mechanism             |
-| `config`          | `unknown`                        | Optional configuration data for the module        |
-| `importOverrides` | `Record<string, string[]>`       | Optional mapping of import paths to alternatives  |
-| `disabledExports` | `string[]`                       | Optional list of exports to hide from this module |
+| Property          | Type                             | Description                                            |
+| ----------------- | -------------------------------- | ------------------------------------------------------ |
+| `source`          | `{ type: string } & Record<...>` | Source location and loading mechanism                  |
+| `config`          | `unknown`                        | Optional configuration data for the module             |
+| `importOverrides` | `Record<string, string[]>`       | Optional runtime import override map with array values |
+| `disabledExports` | `string[]`                       | Optional list of exports to hide from this module      |
+
+`ModuleDefinition` is the runtime management contract used by `LoadModule` and `GetModuleInfo`. It is not the project-file `AntelopeModuleConfig`: that type uses `ImportOverride[] | Record<string, string>` for declarative provider bindings and named connections. The different `importOverrides` shapes are intentional; do not copy one into the other or cast between them. `SaveModuleDeclaration` uses the project-file shape. See [project configuration](./7.configuration.md#antelopemoduleconfig) for that contract.
 
 ## `ModuleInfo`
 

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                                                                                                      |
@@ -167,9 +186,11 @@ Full module configuration within the project config.
 
 An `ImportOverride` is `{ interface, source?, id? }`. The first entry for an interface pins it to the `source` module; further entries are connections reached through `GetInterfaceInstance(interface, id)`. An entry for a standalone interface may omit `source`, declaring a connection to that self-hosted interface.
 
+This project-file contract also applies to `SaveModuleDeclaration`. It differs intentionally from the runtime `ModuleDefinition.importOverrides: Record<string, string[]>` accepted by `LoadModule`; the two types are not interchangeable. Use the type of the API you are calling rather than changing or casting the override shape.
+
 ## `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/docs/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "rootDir": "..",
+    "composite": false,
+    "incremental": false,
+    "noEmit": true,
+    "paths": {
+      "@antelopejs/interface-core": ["../src/index.ts"],
+      "@antelopejs/interface-core/*": ["../src/*"]
+    }
+  },
+  "include": ["../src", "./**/*.ts"]
+}

package/package.json

@@ -1,12 +1,19 @@
 {
   "name": "@antelopejs/interface-core",
-  "version": "0.2.3",
-  "description": "AntelopeJS core interface primitives - proxies, decorators, interface functions, and logging",
+  "version": "0.2.5",
+  "description": "AntelopeJS core interface primitives: proxies, interface functions, decorators, module lifecycle, logging and configuration",
   "keywords": [
     "antelopejs",
     "core",
-    "interface"
+    "decorators",
+    "interface",
+    "logging",
+    "proxy"
   ],
+  "homepage": "https://interfaces.antelopejs.com/docs/core",
+  "bugs": {
+    "url": "https://github.com/AntelopeJS/interface-core/issues"
+  },
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -90,7 +97,7 @@
     "reflect-metadata": "^0.2.2"
   },
   "devDependencies": {
-    "@antelopejs/tooling-configs": "^0.0.8",
+    "@antelopejs/tooling-configs": "^0.0.9",
     "@types/chai": "^4.3.20",
     "@types/mocha": "^10.0.10",
     "@types/node": "^22.19.15",

package/skills/core-interface/SKILL.md

@@ -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;