moost 0.6.41 → 0.6.43

package/dist/index.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 let _wooksjs_event_core = require("@wooksjs/event-core");
-let _prostojs_infact = require("@prostojs/infact");
 let _prostojs_mate = require("@prostojs/mate");
 let _prostojs_logger = require("@prostojs/logger");
+let _prostojs_infact = require("@prostojs/infact");
 let hookable = require("hookable");
 let wooks = require("wooks");
 
@@ -48,12 +48,38 @@ let stamped = false;
 	if (stamped) return;
 	stamped = true;
 	stampModuleIdentity({
-		version: "0.6.41",
+		version: "0.6.43",
 		path: typeof __filename === "string" ? __filename : require("url").pathToFileURL(__filename).href
 	});
 }
 stampOnce();
 
+//#endregion
+//#region packages/moost/src/adapter-brand.ts
+/**
+* Static key an adapter class names itself under, independently of its class
+* identity — e.g. `static readonly [MOOST_ADAPTER_BRAND] = '@moostjs/event-http/MoostHttp'`.
+*
+* DI keys classes by identity. When two copies of an adapter package are loaded
+* (a dev server evaluating one copy while Node loads another for an externalized
+* dependency, or a bundle next to an external), a library resolving the adapter
+* with `useControllerContext().instantiate(MoostHttp)` holds the *other* copy's
+* class and finds nothing. With a brand, `instantiate()` still returns the
+* attached adapter (and warns once about the duplicate copy).
+*/ const MOOST_ADAPTER_BRAND = Symbol.for("moost:adapter-brand");
+/** The {@link MOOST_ADAPTER_BRAND} of a class (inherited by subclasses), if it carries one. */ function getAdapterBrand(classConstructor) {
+	if (typeof classConstructor !== "function") return;
+	const brand = classConstructor[MOOST_ADAPTER_BRAND];
+	return typeof brand === "string" ? brand : void 0;
+}
+/**
+* Provide-registry token `Moost.init()` files a branded adapter under next to its
+* class — the lookup `instantiate()` uses for an adapter class that is not the
+* attached one (another package copy, or a base class of the attached adapter).
+*/ function adapterProvideToken(brand) {
+	return `moost:adapter:${brand}`;
+}
+
 //#endregion
 //#region packages/moost/src/logger.ts
 let defaultLogger;
@@ -96,6 +122,124 @@ function getDefaultLogger(topic) {
 	return merged.toSorted((a, b) => a.priority - b.priority);
 }
 
+//#endregion
+//#region packages/moost/src/event-scope.ts
+function _define_property$2(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+	else obj[key] = value;
+	return obj;
+}
+let _scopeChar = "a";
+let _scopeNum = 0;
+function nextScopeId() {
+	if (_scopeNum >= Number.MAX_SAFE_INTEGER) {
+		_scopeNum = 0;
+		_scopeChar = _scopeChar === "z" ? "a" : String.fromCodePoint((_scopeChar.codePointAt(0) ?? 97) + 1);
+	}
+	return `__moost_${_scopeChar}_${++_scopeNum}`;
+}
+const scopeIdSlot = (0, _wooksjs_event_core.cached)(() => nextScopeId());
+/**
+* Composable returning the moost DI scope ID of the current event. Generated on first call
+* and cached on the event context itself — never inherited from a parent context, so a child
+* event (a workflow run started with `eventContext`, a WebSocket message) owns its scope
+* instead of sharing, and later releasing, its parent's.
+*/ const useScopeId = (ctx) => (ctx ?? (0, _wooksjs_event_core.current)()).getOwn(scopeIdSlot);
+/** Registers a DI scope for the given ID and returns an unscope function. */ function registerEventScope(scopeId) {
+	const infact = getMoostInfact();
+	infact.registerScope(scopeId);
+	return () => {
+		infact.unregisterScope(scopeId);
+	};
+}
+const NO_ISOLATION = /* @__PURE__ */ new Set();
+/** Copy-on-write child: reads fall through to the parent, every write stays in the child. */ let ForkedEventContext = class ForkedEventContext extends _wooksjs_event_core.EventContext {
+	set(slot, value) {
+		this.setOwn(slot, value);
+	}
+	_shouldTraverseParent(id) {
+		return !this.isolated.has(id);
+	}
+	constructor(parent, isolated) {
+		super({
+			logger: parent.logger,
+			parent
+		}), _define_property$2(this, "isolated", void 0), this.isolated = isolated;
+	}
+};
+/**
+* Creates a copy-on-write child of an event context. Reads fall through to the parent
+* (request, headers, auth, already computed slots); every write — `ctx.set()`, a controller
+* context, a composable's state — stays in the child, so running code in the child never
+* clobbers the parent event's state. The child owns its moost DI scope id (see
+* {@link withControllerContext} to share the parent's).
+*
+* Run code in it with `run(child, fn)`.
+*
+* @example
+* ```ts
+* const child = forkEventContext({ isolate: [useMyState] })
+* await run(child, () => doWork())
+* ```
+*/ function forkEventContext(opts) {
+	const parent = opts?.parent ?? (0, _wooksjs_event_core.current)();
+	if (!opts?.isolate) return new ForkedEventContext(parent, NO_ISOLATION);
+	const ids = /* @__PURE__ */ new Set();
+	for (const slot of opts.isolate) ids.add(("_slot" in slot ? slot._slot : slot)._id);
+	return new ForkedEventContext(parent, ids);
+}
+/**
+* Runs `fn` in a copy-on-write child of the current event (see {@link forkEventContext})
+* whose controller context is `instance` / `method` — another controller's hooks, permission
+* checks and `useControllerContext()` consumers run as if the event had been routed to it,
+* without touching the current event's state. `FOR_EVENT` dependencies resolve in the parent's
+* DI scope by default (`shareScope`).
+*
+* Use it to call into another controller's logic within the same event. Do not run a moost
+* event handler (a routed handler function) inside a scope-sharing child: a handler registers
+* and releases its own scope — use an adapter-level invocation (e.g. `MoostHttp.invoke()`) for that.
+*
+* @returns what `fn` returns (a promise stays a promise)
+*
+* @example
+* ```ts
+* const source = await useControllerContext().instantiate(IssueController)
+* const allowed = await withControllerContext(source, 'list', () => source.allowedFor(ids))
+* ```
+*/ function withControllerContext(instance, method, fn, opts) {
+	const parent = opts?.parent ?? (0, _wooksjs_event_core.current)();
+	const child = forkEventContext({
+		parent,
+		isolate: opts?.isolate
+	});
+	setControllerContext(instance, method, opts?.route ?? "", {
+		prefix: opts?.prefix,
+		ctx: child
+	});
+	if (opts?.shareScope !== false) {
+		child.setOwn(scopeIdSlot, useScopeId(parent));
+		return (0, _wooksjs_event_core.run)(child, fn);
+	}
+	const release = registerEventScope(useScopeId(child));
+	let result;
+	try {
+		result = (0, _wooksjs_event_core.run)(child, fn);
+	} catch (error) {
+		release();
+		throw error;
+	}
+	if (!isThenable(result)) {
+		release();
+		return result;
+	}
+	return Promise.resolve(result).finally(release);
+}
+
 //#endregion
 //#region packages/moost/src/pipes/run-pipes.ts
 function runPipes(pipes, initialValue, metas, level) {
@@ -389,6 +533,23 @@ const controllerPrefixKey = globalKey("controller.prefix");
 	_ctx.set(controllerRouteKey, route);
 	if (opts?.prefix !== void 0) _ctx.set(controllerPrefixKey, opts.prefix);
 }
+/** Brands already warned about by {@link brandedAdapterFor} (one warning per process). */ const reportedAdapterCopies = /* @__PURE__ */ new Set();
+/**
+* The attached adapter `instantiate(c)` resolves through its brand (see `MOOST_ADAPTER_BRAND`)
+* when `c` is not that adapter's own class: a base class of a custom adapter, or the adapter class
+* from another copy of its package (warned once). `undefined` → the plain DI lookup applies.
+*/ function brandedAdapterFor(controller, c) {
+	const brand = getAdapterBrand(c);
+	if (brand === void 0) return;
+	const adapter = getMoostInfact().getInstanceRegistries(controller).provide?.[adapterProvideToken(brand)]?.fn();
+	const attached = adapter ? (0, _prostojs_mate.getConstructor)(adapter) : void 0;
+	if (!attached || attached === c || c.prototype instanceof attached) return;
+	if (!(adapter instanceof c) && !reportedAdapterCopies.has(brand)) {
+		reportedAdapterCopies.add(brand);
+		getDefaultLogger("moost").warn(`instantiate(${c.name}) resolved the attached adapter through its brand "${brand}": the class passed in comes from another copy of its package. Two copies of a package split its module state — make the bundler / SSR externalization load one copy (for @moostjs/vite see the ssrExternalCheck warnings).`);
+	}
+	return adapter;
+}
 /**
 * Provides access to the current controller context within an event handler.
 * Returns utilities for accessing the controller instance, method metadata, and DI.
@@ -401,7 +562,9 @@ const controllerPrefixKey = globalKey("controller.prefix");
 	const getControllerMeta = () => getMoostMate().read(getController());
 	const getMethodMeta = (name) => getMoostMate().read(getController(), name || getMethod());
 	function instantiate(c) {
-		return getMoostInfact().getForInstance(getController(), c);
+		const controller = getController();
+		const adapter = brandedAdapterFor(controller, c);
+		return adapter ? Promise.resolve(adapter) : getMoostInfact().getForInstance(controller, c);
 	}
 	return {
 		instantiate,
@@ -437,21 +600,33 @@ const interceptResultKey = globalKey("interceptor.result");
 
 //#endregion
 //#region packages/moost/src/adapter-utils.ts
-let _scopeChar = "a";
-let _scopeNum = 0;
-function nextScopeId() {
-	if (_scopeNum >= Number.MAX_SAFE_INTEGER) {
-		_scopeNum = 0;
-		_scopeChar = _scopeChar === "z" ? "a" : String.fromCodePoint((_scopeChar.codePointAt(0) ?? 97) + 1);
-	}
-	return `__moost_${_scopeChar}_${++_scopeNum}`;
-}
-/** Composable returning the moost scope ID for the current event. Generates on first call, caches for subsequent calls. */ const useScopeId = (0, _wooksjs_event_core.defineWook)(() => nextScopeId());
-/** Registers a DI scope for the given ID and returns an unscope function. */ function registerEventScope(scopeId) {
-	const infact = getMoostInfact();
-	infact.registerScope(scopeId);
-	return () => {
-		infact.unregisterScope(scopeId);
+const noop = () => {};
+/**
+* Registers an event's DI scope, held by its handler lifecycle and, with `adapterHolds`, by
+* the adapter too. Each release is idempotent; the scope is dropped once every holder let go,
+* so an adapter signal that fires early (a client disconnect mid-handler) cannot pull the
+* scope from under a running handler. Built outside the handler closure so a long-lived
+* adapter listener (the response 'close' of a streamed body) retains only the scope.
+*/ function holdEventScope(scopeId, adapterHolds) {
+	const drop = registerEventScope(scopeId);
+	let holders = adapterHolds ? 2 : 1;
+	const hold = () => {
+		let held = true;
+		return () => {
+			if (held) {
+				held = false;
+				if (--holders === 0) drop();
+			}
+		};
+	};
+	const releaseLifecycle = hold();
+	return {
+		releaseLifecycle,
+		failLifecycle: (error) => {
+			releaseLifecycle();
+			throw error;
+		},
+		unscope: adapterHolds ? hold() : noop
 	};
 }
 /**
@@ -460,6 +635,7 @@ function nextScopeId() {
 * handler invocation, and cleanup — optimised for sync-first execution.
 */ function defineMoostEventHandler(options) {
 	const ci = (0, _wooksjs_event_core.getContextInjector)();
+	const manualUnscope = !!options.manualUnscope;
 	const handlerSpanName = `Handler:${options.targetPath}`;
 	const handlerAttrs = {
 		"moost.handler": options.controllerMethod || "",
@@ -469,7 +645,7 @@ function nextScopeId() {
 		const ctx = (0, _wooksjs_event_core.current)();
 		const scopeId = useScopeId(ctx);
 		const logger = (0, _wooksjs_event_core.useLogger)(options.loggerTitle, ctx);
-		const unscope = registerEventScope(scopeId);
+		const { unscope, releaseLifecycle, failLifecycle } = holdEventScope(scopeId, manualUnscope);
 		let response;
 		let hookOptions;
 		function getHookOptions() {
@@ -485,14 +661,17 @@ function nextScopeId() {
 		let interceptorHandler;
 		let raise = false;
 		try {
+			const result = start();
+			return isThenable(result) ? result.then(void 0, failLifecycle) : result;
+		} catch (error) {
+			return failLifecycle(error);
+		}
+		function start() {
 			if (options.hooks?.init) {
 				const hookResult = options.hooks.init(getHookOptions());
 				if (isThenable(hookResult)) return hookResult.then(afterInit);
 			}
 			return afterInit();
-		} catch (error) {
-			if (!options.manualUnscope) unscope();
-			throw error;
 		}
 		function afterInit() {
 			const instanceResult = options.getControllerInstance();
@@ -576,7 +755,6 @@ function nextScopeId() {
 					return finalize();
 				}, (error) => {
 					if (options.logErrors) logger.error(String(error));
-					if (!options.manualUnscope) unscope();
 					throw error;
 				});
 				response = afterResult;
@@ -585,7 +763,7 @@ function nextScopeId() {
 			return finalize();
 		}
 		function finalize() {
-			if (!options.manualUnscope) unscope();
+			releaseLifecycle();
 			if (options.hooks?.end) {
 				const endResult = options.hooks.end(getHookOptions());
 				if (isThenable(endResult)) return endResult.then(() => {
@@ -2138,7 +2316,11 @@ function _define_property(obj, key, value) {
 		this.setProvideRegistry((0, _prostojs_infact.createProvideRegistry)([Moost, () => this], [_prostojs_logger.ProstoLogger, () => this.logger], ["MOOST_LOGGER", () => this.logger]));
 		for (const a of this.adapters) {
 			const constructor = (0, _prostojs_mate.getConstructor)(a);
-			if (constructor) this.setProvideRegistry((0, _prostojs_infact.createProvideRegistry)([constructor, () => a]));
+			if (constructor) {
+				this.setProvideRegistry((0, _prostojs_infact.createProvideRegistry)([constructor, () => a]));
+				const brand = getAdapterBrand(constructor);
+				if (brand !== void 0) this.setProvideRegistry((0, _prostojs_infact.createProvideRegistry)([adapterProvideToken(brand), () => a]));
+			}
 			if (typeof a.getProvideRegistry === "function") this.setProvideRegistry(a.getProvideRegistry());
 		}
 		this.unregisteredControllers.unshift({ controller: this });
@@ -2592,6 +2774,7 @@ exports.Interceptor = Interceptor;
 exports.InterceptorHandler = InterceptorHandler;
 exports.Label = Label;
 exports.LoggerTopic = LoggerTopic;
+exports.MOOST_ADAPTER_BRAND = MOOST_ADAPTER_BRAND;
 exports.MOOST_MODULE_IDENTITY_KEY = MOOST_MODULE_IDENTITY_KEY;
 exports.Moost = Moost;
 exports.MoostDispose = MoostDispose;
@@ -2667,6 +2850,7 @@ Object.defineProperty(exports, 'eventTypeKey', {
     return _wooksjs_event_core.eventTypeKey;
   }
 });
+exports.forkEventContext = forkEventContext;
 Object.defineProperty(exports, 'getClassKey', {
   enumerable: true,
   get: function () {
@@ -2751,4 +2935,5 @@ Object.defineProperty(exports, 'useLogger', {
   }
 });
 exports.useOvertake = useOvertake;
-exports.useScopeId = useScopeId;
+exports.useScopeId = useScopeId;
+exports.withControllerContext = withControllerContext;

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import * as _wooksjs_event_core from '@wooksjs/event-core';
-import { EventContext, Logger, Key } from '@wooksjs/event-core';
+import { EventContext, Logger, Accessor, Key } from '@wooksjs/event-core';
 export { Cached, ContextInjector, EventContext, EventContextOptions, Key, Logger, cached, createEventContext, current, eventTypeKey, getContextInjector, key, replaceContextInjector, resetContextInjector, run, useLogger } from '@wooksjs/event-core';
 import { TProvideRegistry, TReplaceRegistry, Infact, TProvideFn } from '@prostojs/infact';
 export { TProvideRegistry, createProvideRegistry, createReplaceRegistry, getClassKey } from '@prostojs/infact';
@@ -1288,10 +1287,6 @@ interface TMoostEventHandlerOptions<T> {
     controllerPrefix?: string;
     handlerType: string;
 }
-/** Composable returning the moost scope ID for the current event. Generates on first call, caches for subsequent calls. */
-declare const useScopeId: _wooksjs_event_core.WookComposable<string>;
-/** Registers a DI scope for the given ID and returns an unscope function. */
-declare function registerEventScope(scopeId: string): () => void;
 /**
  * Creates the complete event handler lifecycle processor used by adapters.
  * Handles scope registration, controller resolution, interceptors, argument resolution,
@@ -1299,6 +1294,96 @@ declare function registerEventScope(scopeId: string): () => void;
  */
 declare function defineMoostEventHandler<T>(options: TMoostEventHandlerOptions<T>): () => unknown;
 
+/**
+ * Static key an adapter class names itself under, independently of its class
+ * identity — e.g. `static readonly [MOOST_ADAPTER_BRAND] = '@moostjs/event-http/MoostHttp'`.
+ *
+ * DI keys classes by identity. When two copies of an adapter package are loaded
+ * (a dev server evaluating one copy while Node loads another for an externalized
+ * dependency, or a bundle next to an external), a library resolving the adapter
+ * with `useControllerContext().instantiate(MoostHttp)` holds the *other* copy's
+ * class and finds nothing. With a brand, `instantiate()` still returns the
+ * attached adapter (and warns once about the duplicate copy).
+ */
+declare const MOOST_ADAPTER_BRAND: unique symbol;
+
+/**
+ * Composable returning the moost DI scope ID of the current event. Generated on first call
+ * and cached on the event context itself — never inherited from a parent context, so a child
+ * event (a workflow run started with `eventContext`, a WebSocket message) owns its scope
+ * instead of sharing, and later releasing, its parent's.
+ */
+declare const useScopeId: (ctx?: EventContext) => string;
+/** Registers a DI scope for the given ID and returns an unscope function. */
+declare function registerEventScope(scopeId: string): () => void;
+/** A slot a child context must not read through from its parent: a `key()` / `cached()` slot, or a `defineWook` composable. */
+type TIsolatedSlot = Accessor<any> | {
+    readonly _slot: Accessor<any>;
+};
+/** Options for {@link forkEventContext}. */
+interface TForkEventContextOptions {
+    /** The context to fork. Default: the current event context. */
+    parent?: EventContext;
+    /**
+     * Slots the child never reads through from the parent — they are computed or stored in
+     * the child only. Pass the per-event state the child must not inherit (a composable the
+     * parent already built is bound to the parent's context).
+     */
+    isolate?: Iterable<TIsolatedSlot>;
+}
+/**
+ * Creates a copy-on-write child of an event context. Reads fall through to the parent
+ * (request, headers, auth, already computed slots); every write — `ctx.set()`, a controller
+ * context, a composable's state — stays in the child, so running code in the child never
+ * clobbers the parent event's state. The child owns its moost DI scope id (see
+ * {@link withControllerContext} to share the parent's).
+ *
+ * Run code in it with `run(child, fn)`.
+ *
+ * @example
+ * ```ts
+ * const child = forkEventContext({ isolate: [useMyState] })
+ * await run(child, () => doWork())
+ * ```
+ */
+declare function forkEventContext(opts?: TForkEventContextOptions): EventContext;
+/** Options for {@link withControllerContext}. */
+interface TWithControllerContextOptions extends TForkEventContextOptions {
+    /**
+     * `true` (default): the child runs in the parent event's DI scope — `FOR_EVENT` instances
+     * resolve to (and are shared with) the parent event's. The parent must be a moost event
+     * whose handler is still running.
+     *
+     * `false`: the child gets its own DI scope, registered for the duration of `fn` and
+     * released when `fn` settles — `FOR_EVENT` instances are fresh and dropped afterwards.
+     */
+    shareScope?: boolean;
+    /** The route reported by `useControllerContext().getRoute()` in the child. Default: `''`. */
+    route?: string;
+    /** The prefix reported by `useControllerContext().getPrefix()` in the child. */
+    prefix?: string;
+}
+/**
+ * Runs `fn` in a copy-on-write child of the current event (see {@link forkEventContext})
+ * whose controller context is `instance` / `method` — another controller's hooks, permission
+ * checks and `useControllerContext()` consumers run as if the event had been routed to it,
+ * without touching the current event's state. `FOR_EVENT` dependencies resolve in the parent's
+ * DI scope by default (`shareScope`).
+ *
+ * Use it to call into another controller's logic within the same event. Do not run a moost
+ * event handler (a routed handler function) inside a scope-sharing child: a handler registers
+ * and releases its own scope — use an adapter-level invocation (e.g. `MoostHttp.invoke()`) for that.
+ *
+ * @returns what `fn` returns (a promise stays a promise)
+ *
+ * @example
+ * ```ts
+ * const source = await useControllerContext().instantiate(IssueController)
+ * const allowed = await withControllerContext(source, 'list', () => source.allowedFor(ids))
+ * ```
+ */
+declare function withControllerContext<T extends object, R>(instance: T, method: keyof T | string, fn: () => R, opts?: TWithControllerContextOptions): R;
+
 /**
  * Returns the own method names of an instance, including inherited methods
  * from parent classes.
@@ -1455,5 +1540,5 @@ declare function createLogger(opts?: Partial<TProstoLoggerOptions>): ProstoLogge
 /** Default colored console transport used by Moost loggers. */
 declare const loggerConsoleTransport: _prostojs_logger.TProstoLoggerTransportFn<any>;
 
-export { After, ApplyDecorators, Before, Circular, Const, ConstFactory, Controller, Description, HandlerPaths, Id, ImportController, Inherit, Inject, InjectEventLogger, InjectFromScope, InjectMoost, InjectMoostLogger, InjectScopeVars, Injectable, Intercept, Interceptor, InterceptorHandler, Label, LoggerTopic, MOOST_MODULE_IDENTITY_KEY, Moost, MoostDispose, MoostInit, OnError, Optional, Overtake, Param, Params, Pipe, Provide, Replace, Required, Resolve, Response, TInterceptorPriority, TPipePriority, Value, createLogger, defineAfterInterceptor, defineBeforeInterceptor, defineErrorInterceptor, defineInfactScope, defineInterceptor, defineMoostEventHandler, definePipeFn, disposeInstances, getHandlerPaths, getInfactScopeVars, getInfactSingletonInstances, getInstanceOwnMethods, getInstanceOwnProps, getMoostInfact, getMoostMate, getNewMoostInfact, globalKey, isThenable, loggerConsoleTransport, mergeSorted, registerEventScope, resolvePipe, setControllerContext, setInfactLoggingOptions, setInterceptResult, setOvertake, stampModuleIdentity, stampOnce, useControllerContext, useHandlerPaths, useInterceptResult, useOvertake, useScopeId };
-export type { TAny, TAnyFn, TClassConstructor, TContextInjectorHook, TControllerOverview, TControllerRegistration, TControllersGroup, TDisposeError, TDisposeOptions, TDisposeResult, TEmpty, TFunction, TGetHandlerPathsOptions, TInjectableScope, TInterceptorAfterFn, TInterceptorBeforeFn, TInterceptorData, TInterceptorDef, TInterceptorDefFactory, TInterceptorEntry, TInterceptorErrorFn, TLogger, TMoostAdapter, TMoostAdapterOptions, TMoostEventHandlerHookOptions, TMoostEventHandlerOptions, TMoostHandler, TMoostMetadata, TMoostModuleIdentity, TMoostOptions, TMoostParamsMetadata, TObject, TOvertakeFn, TPipeData, TPipeFn, TPipeMetas, TPrimitives };
+export { After, ApplyDecorators, Before, Circular, Const, ConstFactory, Controller, Description, HandlerPaths, Id, ImportController, Inherit, Inject, InjectEventLogger, InjectFromScope, InjectMoost, InjectMoostLogger, InjectScopeVars, Injectable, Intercept, Interceptor, InterceptorHandler, Label, LoggerTopic, MOOST_ADAPTER_BRAND, MOOST_MODULE_IDENTITY_KEY, Moost, MoostDispose, MoostInit, OnError, Optional, Overtake, Param, Params, Pipe, Provide, Replace, Required, Resolve, Response, TInterceptorPriority, TPipePriority, Value, createLogger, defineAfterInterceptor, defineBeforeInterceptor, defineErrorInterceptor, defineInfactScope, defineInterceptor, defineMoostEventHandler, definePipeFn, disposeInstances, forkEventContext, getHandlerPaths, getInfactScopeVars, getInfactSingletonInstances, getInstanceOwnMethods, getInstanceOwnProps, getMoostInfact, getMoostMate, getNewMoostInfact, globalKey, isThenable, loggerConsoleTransport, mergeSorted, registerEventScope, resolvePipe, setControllerContext, setInfactLoggingOptions, setInterceptResult, setOvertake, stampModuleIdentity, stampOnce, useControllerContext, useHandlerPaths, useInterceptResult, useOvertake, useScopeId, withControllerContext };
+export type { TAny, TAnyFn, TClassConstructor, TContextInjectorHook, TControllerOverview, TControllerRegistration, TControllersGroup, TDisposeError, TDisposeOptions, TDisposeResult, TEmpty, TForkEventContextOptions, TFunction, TGetHandlerPathsOptions, TInjectableScope, TInterceptorAfterFn, TInterceptorBeforeFn, TInterceptorData, TInterceptorDef, TInterceptorDefFactory, TInterceptorEntry, TInterceptorErrorFn, TIsolatedSlot, TLogger, TMoostAdapter, TMoostAdapterOptions, TMoostEventHandlerHookOptions, TMoostEventHandlerOptions, TMoostHandler, TMoostMetadata, TMoostModuleIdentity, TMoostOptions, TMoostParamsMetadata, TObject, TOvertakeFn, TPipeData, TPipeFn, TPipeMetas, TPrimitives, TWithControllerContextOptions };

package/dist/index.mjs

@@ -1,7 +1,7 @@
-import { ContextInjector, cached, createEventContext, createEventContext as createEventContext$1, current, current as current$1, defineWook, eventTypeKey, getContextInjector, getContextInjector as getContextInjector$1, key, key as key$1, replaceContextInjector, resetContextInjector, run, useLogger, useLogger as useLogger$1, useRouteParams } from "@wooksjs/event-core";
-import { Infact, createProvideRegistry, createProvideRegistry as createProvideRegistry$1, createReplaceRegistry, createReplaceRegistry as createReplaceRegistry$1, getClassKey, getClassKey as getClassKey$1 } from "@prostojs/infact";
+import { ContextInjector, EventContext, cached, cached as cached$1, createEventContext, createEventContext as createEventContext$1, current, current as current$1, eventTypeKey, getContextInjector, getContextInjector as getContextInjector$1, key, key as key$1, replaceContextInjector, resetContextInjector, run, run as run$1, useLogger, useLogger as useLogger$1, useRouteParams } from "@wooksjs/event-core";
 import { Mate, getConstructor, getConstructor as getConstructor$1, isConstructor, isConstructor as isConstructor$1 } from "@prostojs/mate";
 import { ProstoLogger, ProstoLogger as ProstoLogger$1, coloredConsole, createConsoleTransort } from "@prostojs/logger";
+import { Infact, createProvideRegistry, createProvideRegistry as createProvideRegistry$1, createReplaceRegistry, createReplaceRegistry as createReplaceRegistry$1, getClassKey, getClassKey as getClassKey$1 } from "@prostojs/infact";
 import { Hookable } from "hookable";
 import { clearGlobalWooks, getGlobalWooks } from "wooks";
 
@@ -47,12 +47,38 @@ let stamped = false;
 	if (stamped) return;
 	stamped = true;
 	stampModuleIdentity({
-		version: "0.6.41",
+		version: "0.6.43",
 		path: typeof __filename === "string" ? __filename : import.meta.url
 	});
 }
 stampOnce();
 
+//#endregion
+//#region packages/moost/src/adapter-brand.ts
+/**
+* Static key an adapter class names itself under, independently of its class
+* identity — e.g. `static readonly [MOOST_ADAPTER_BRAND] = '@moostjs/event-http/MoostHttp'`.
+*
+* DI keys classes by identity. When two copies of an adapter package are loaded
+* (a dev server evaluating one copy while Node loads another for an externalized
+* dependency, or a bundle next to an external), a library resolving the adapter
+* with `useControllerContext().instantiate(MoostHttp)` holds the *other* copy's
+* class and finds nothing. With a brand, `instantiate()` still returns the
+* attached adapter (and warns once about the duplicate copy).
+*/ const MOOST_ADAPTER_BRAND = Symbol.for("moost:adapter-brand");
+/** The {@link MOOST_ADAPTER_BRAND} of a class (inherited by subclasses), if it carries one. */ function getAdapterBrand(classConstructor) {
+	if (typeof classConstructor !== "function") return;
+	const brand = classConstructor[MOOST_ADAPTER_BRAND];
+	return typeof brand === "string" ? brand : void 0;
+}
+/**
+* Provide-registry token `Moost.init()` files a branded adapter under next to its
+* class — the lookup `instantiate()` uses for an adapter class that is not the
+* attached one (another package copy, or a base class of the attached adapter).
+*/ function adapterProvideToken(brand) {
+	return `moost:adapter:${brand}`;
+}
+
 //#endregion
 //#region packages/moost/src/logger.ts
 let defaultLogger;
@@ -95,6 +121,124 @@ function getDefaultLogger(topic) {
 	return merged.toSorted((a, b) => a.priority - b.priority);
 }
 
+//#endregion
+//#region packages/moost/src/event-scope.ts
+function _define_property$2(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+	else obj[key] = value;
+	return obj;
+}
+let _scopeChar = "a";
+let _scopeNum = 0;
+function nextScopeId() {
+	if (_scopeNum >= Number.MAX_SAFE_INTEGER) {
+		_scopeNum = 0;
+		_scopeChar = _scopeChar === "z" ? "a" : String.fromCodePoint((_scopeChar.codePointAt(0) ?? 97) + 1);
+	}
+	return `__moost_${_scopeChar}_${++_scopeNum}`;
+}
+const scopeIdSlot = cached$1(() => nextScopeId());
+/**
+* Composable returning the moost DI scope ID of the current event. Generated on first call
+* and cached on the event context itself — never inherited from a parent context, so a child
+* event (a workflow run started with `eventContext`, a WebSocket message) owns its scope
+* instead of sharing, and later releasing, its parent's.
+*/ const useScopeId = (ctx) => (ctx ?? current$1()).getOwn(scopeIdSlot);
+/** Registers a DI scope for the given ID and returns an unscope function. */ function registerEventScope(scopeId) {
+	const infact = getMoostInfact();
+	infact.registerScope(scopeId);
+	return () => {
+		infact.unregisterScope(scopeId);
+	};
+}
+const NO_ISOLATION = /* @__PURE__ */ new Set();
+/** Copy-on-write child: reads fall through to the parent, every write stays in the child. */ let ForkedEventContext = class ForkedEventContext extends EventContext {
+	set(slot, value) {
+		this.setOwn(slot, value);
+	}
+	_shouldTraverseParent(id) {
+		return !this.isolated.has(id);
+	}
+	constructor(parent, isolated) {
+		super({
+			logger: parent.logger,
+			parent
+		}), _define_property$2(this, "isolated", void 0), this.isolated = isolated;
+	}
+};
+/**
+* Creates a copy-on-write child of an event context. Reads fall through to the parent
+* (request, headers, auth, already computed slots); every write — `ctx.set()`, a controller
+* context, a composable's state — stays in the child, so running code in the child never
+* clobbers the parent event's state. The child owns its moost DI scope id (see
+* {@link withControllerContext} to share the parent's).
+*
+* Run code in it with `run(child, fn)`.
+*
+* @example
+* ```ts
+* const child = forkEventContext({ isolate: [useMyState] })
+* await run(child, () => doWork())
+* ```
+*/ function forkEventContext(opts) {
+	const parent = opts?.parent ?? current$1();
+	if (!opts?.isolate) return new ForkedEventContext(parent, NO_ISOLATION);
+	const ids = /* @__PURE__ */ new Set();
+	for (const slot of opts.isolate) ids.add(("_slot" in slot ? slot._slot : slot)._id);
+	return new ForkedEventContext(parent, ids);
+}
+/**
+* Runs `fn` in a copy-on-write child of the current event (see {@link forkEventContext})
+* whose controller context is `instance` / `method` — another controller's hooks, permission
+* checks and `useControllerContext()` consumers run as if the event had been routed to it,
+* without touching the current event's state. `FOR_EVENT` dependencies resolve in the parent's
+* DI scope by default (`shareScope`).
+*
+* Use it to call into another controller's logic within the same event. Do not run a moost
+* event handler (a routed handler function) inside a scope-sharing child: a handler registers
+* and releases its own scope — use an adapter-level invocation (e.g. `MoostHttp.invoke()`) for that.
+*
+* @returns what `fn` returns (a promise stays a promise)
+*
+* @example
+* ```ts
+* const source = await useControllerContext().instantiate(IssueController)
+* const allowed = await withControllerContext(source, 'list', () => source.allowedFor(ids))
+* ```
+*/ function withControllerContext(instance, method, fn, opts) {
+	const parent = opts?.parent ?? current$1();
+	const child = forkEventContext({
+		parent,
+		isolate: opts?.isolate
+	});
+	setControllerContext(instance, method, opts?.route ?? "", {
+		prefix: opts?.prefix,
+		ctx: child
+	});
+	if (opts?.shareScope !== false) {
+		child.setOwn(scopeIdSlot, useScopeId(parent));
+		return run$1(child, fn);
+	}
+	const release = registerEventScope(useScopeId(child));
+	let result;
+	try {
+		result = run$1(child, fn);
+	} catch (error) {
+		release();
+		throw error;
+	}
+	if (!isThenable(result)) {
+		release();
+		return result;
+	}
+	return Promise.resolve(result).finally(release);
+}
+
 //#endregion
 //#region packages/moost/src/pipes/run-pipes.ts
 function runPipes(pipes, initialValue, metas, level) {
@@ -388,6 +532,23 @@ const controllerPrefixKey = globalKey("controller.prefix");
 	_ctx.set(controllerRouteKey, route);
 	if (opts?.prefix !== void 0) _ctx.set(controllerPrefixKey, opts.prefix);
 }
+/** Brands already warned about by {@link brandedAdapterFor} (one warning per process). */ const reportedAdapterCopies = /* @__PURE__ */ new Set();
+/**
+* The attached adapter `instantiate(c)` resolves through its brand (see `MOOST_ADAPTER_BRAND`)
+* when `c` is not that adapter's own class: a base class of a custom adapter, or the adapter class
+* from another copy of its package (warned once). `undefined` → the plain DI lookup applies.
+*/ function brandedAdapterFor(controller, c) {
+	const brand = getAdapterBrand(c);
+	if (brand === void 0) return;
+	const adapter = getMoostInfact().getInstanceRegistries(controller).provide?.[adapterProvideToken(brand)]?.fn();
+	const attached = adapter ? getConstructor$1(adapter) : void 0;
+	if (!attached || attached === c || c.prototype instanceof attached) return;
+	if (!(adapter instanceof c) && !reportedAdapterCopies.has(brand)) {
+		reportedAdapterCopies.add(brand);
+		getDefaultLogger("moost").warn(`instantiate(${c.name}) resolved the attached adapter through its brand "${brand}": the class passed in comes from another copy of its package. Two copies of a package split its module state — make the bundler / SSR externalization load one copy (for @moostjs/vite see the ssrExternalCheck warnings).`);
+	}
+	return adapter;
+}
 /**
 * Provides access to the current controller context within an event handler.
 * Returns utilities for accessing the controller instance, method metadata, and DI.
@@ -400,7 +561,9 @@ const controllerPrefixKey = globalKey("controller.prefix");
 	const getControllerMeta = () => getMoostMate().read(getController());
 	const getMethodMeta = (name) => getMoostMate().read(getController(), name || getMethod());
 	function instantiate(c) {
-		return getMoostInfact().getForInstance(getController(), c);
+		const controller = getController();
+		const adapter = brandedAdapterFor(controller, c);
+		return adapter ? Promise.resolve(adapter) : getMoostInfact().getForInstance(controller, c);
 	}
 	return {
 		instantiate,
@@ -436,21 +599,33 @@ const interceptResultKey = globalKey("interceptor.result");
 
 //#endregion
 //#region packages/moost/src/adapter-utils.ts
-let _scopeChar = "a";
-let _scopeNum = 0;
-function nextScopeId() {
-	if (_scopeNum >= Number.MAX_SAFE_INTEGER) {
-		_scopeNum = 0;
-		_scopeChar = _scopeChar === "z" ? "a" : String.fromCodePoint((_scopeChar.codePointAt(0) ?? 97) + 1);
-	}
-	return `__moost_${_scopeChar}_${++_scopeNum}`;
-}
-/** Composable returning the moost scope ID for the current event. Generates on first call, caches for subsequent calls. */ const useScopeId = defineWook(() => nextScopeId());
-/** Registers a DI scope for the given ID and returns an unscope function. */ function registerEventScope(scopeId) {
-	const infact = getMoostInfact();
-	infact.registerScope(scopeId);
-	return () => {
-		infact.unregisterScope(scopeId);
+const noop = () => {};
+/**
+* Registers an event's DI scope, held by its handler lifecycle and, with `adapterHolds`, by
+* the adapter too. Each release is idempotent; the scope is dropped once every holder let go,
+* so an adapter signal that fires early (a client disconnect mid-handler) cannot pull the
+* scope from under a running handler. Built outside the handler closure so a long-lived
+* adapter listener (the response 'close' of a streamed body) retains only the scope.
+*/ function holdEventScope(scopeId, adapterHolds) {
+	const drop = registerEventScope(scopeId);
+	let holders = adapterHolds ? 2 : 1;
+	const hold = () => {
+		let held = true;
+		return () => {
+			if (held) {
+				held = false;
+				if (--holders === 0) drop();
+			}
+		};
+	};
+	const releaseLifecycle = hold();
+	return {
+		releaseLifecycle,
+		failLifecycle: (error) => {
+			releaseLifecycle();
+			throw error;
+		},
+		unscope: adapterHolds ? hold() : noop
 	};
 }
 /**
@@ -459,6 +634,7 @@ function nextScopeId() {
 * handler invocation, and cleanup — optimised for sync-first execution.
 */ function defineMoostEventHandler(options) {
 	const ci = getContextInjector$1();
+	const manualUnscope = !!options.manualUnscope;
 	const handlerSpanName = `Handler:${options.targetPath}`;
 	const handlerAttrs = {
 		"moost.handler": options.controllerMethod || "",
@@ -468,7 +644,7 @@ function nextScopeId() {
 		const ctx = current$1();
 		const scopeId = useScopeId(ctx);
 		const logger = useLogger$1(options.loggerTitle, ctx);
-		const unscope = registerEventScope(scopeId);
+		const { unscope, releaseLifecycle, failLifecycle } = holdEventScope(scopeId, manualUnscope);
 		let response;
 		let hookOptions;
 		function getHookOptions() {
@@ -484,14 +660,17 @@ function nextScopeId() {
 		let interceptorHandler;
 		let raise = false;
 		try {
+			const result = start();
+			return isThenable(result) ? result.then(void 0, failLifecycle) : result;
+		} catch (error) {
+			return failLifecycle(error);
+		}
+		function start() {
 			if (options.hooks?.init) {
 				const hookResult = options.hooks.init(getHookOptions());
 				if (isThenable(hookResult)) return hookResult.then(afterInit);
 			}
 			return afterInit();
-		} catch (error) {
-			if (!options.manualUnscope) unscope();
-			throw error;
 		}
 		function afterInit() {
 			const instanceResult = options.getControllerInstance();
@@ -575,7 +754,6 @@ function nextScopeId() {
 					return finalize();
 				}, (error) => {
 					if (options.logErrors) logger.error(String(error));
-					if (!options.manualUnscope) unscope();
 					throw error;
 				});
 				response = afterResult;
@@ -584,7 +762,7 @@ function nextScopeId() {
 			return finalize();
 		}
 		function finalize() {
-			if (!options.manualUnscope) unscope();
+			releaseLifecycle();
 			if (options.hooks?.end) {
 				const endResult = options.hooks.end(getHookOptions());
 				if (isThenable(endResult)) return endResult.then(() => {
@@ -2137,7 +2315,11 @@ function _define_property(obj, key, value) {
 		this.setProvideRegistry(createProvideRegistry$1([Moost, () => this], [ProstoLogger$1, () => this.logger], ["MOOST_LOGGER", () => this.logger]));
 		for (const a of this.adapters) {
 			const constructor = getConstructor$1(a);
-			if (constructor) this.setProvideRegistry(createProvideRegistry$1([constructor, () => a]));
+			if (constructor) {
+				this.setProvideRegistry(createProvideRegistry$1([constructor, () => a]));
+				const brand = getAdapterBrand(constructor);
+				if (brand !== void 0) this.setProvideRegistry(createProvideRegistry$1([adapterProvideToken(brand), () => a]));
+			}
 			if (typeof a.getProvideRegistry === "function") this.setProvideRegistry(a.getProvideRegistry());
 		}
 		this.unregisteredControllers.unshift({ controller: this });
@@ -2561,4 +2743,4 @@ function _define_property(obj, key, value) {
 }
 
 //#endregion
-export { After, ApplyDecorators, Before, Circular, Const, ConstFactory, ContextInjector, Controller, Description, HandlerPaths, Id, ImportController, Inherit, Inject, InjectEventLogger, InjectFromScope, InjectMoost, InjectMoostLogger, InjectScopeVars, Injectable, Intercept, Interceptor, InterceptorHandler, Label, LoggerTopic, MOOST_MODULE_IDENTITY_KEY, Moost, MoostDispose, MoostInit, OnError, Optional, Overtake, Param, Params, Pipe, ProstoLogger, Provide, Replace, Required, Resolve, Response, TInterceptorPriority, TPipePriority, Value, cached, clearGlobalWooks, createEventContext, createLogger, createProvideRegistry, createReplaceRegistry, current, defineAfterInterceptor, defineBeforeInterceptor, defineErrorInterceptor, defineInfactScope, defineInterceptor, defineMoostEventHandler, definePipeFn, disposeInstances, eventTypeKey, getClassKey, getConstructor, getContextInjector, getGlobalWooks, getHandlerPaths, getInfactScopeVars, getInfactSingletonInstances, getInstanceOwnMethods, getInstanceOwnProps, getMoostInfact, getMoostMate, getNewMoostInfact, globalKey, isConstructor, isThenable, key, loggerConsoleTransport, mergeSorted, registerEventScope, replaceContextInjector, resetContextInjector, resolvePipe, run, setControllerContext, setInfactLoggingOptions, setInterceptResult, setOvertake, stampModuleIdentity, stampOnce, useControllerContext, useHandlerPaths, useInterceptResult, useLogger, useOvertake, useScopeId };
+export { After, ApplyDecorators, Before, Circular, Const, ConstFactory, ContextInjector, Controller, Description, HandlerPaths, Id, ImportController, Inherit, Inject, InjectEventLogger, InjectFromScope, InjectMoost, InjectMoostLogger, InjectScopeVars, Injectable, Intercept, Interceptor, InterceptorHandler, Label, LoggerTopic, MOOST_ADAPTER_BRAND, MOOST_MODULE_IDENTITY_KEY, Moost, MoostDispose, MoostInit, OnError, Optional, Overtake, Param, Params, Pipe, ProstoLogger, Provide, Replace, Required, Resolve, Response, TInterceptorPriority, TPipePriority, Value, cached, clearGlobalWooks, createEventContext, createLogger, createProvideRegistry, createReplaceRegistry, current, defineAfterInterceptor, defineBeforeInterceptor, defineErrorInterceptor, defineInfactScope, defineInterceptor, defineMoostEventHandler, definePipeFn, disposeInstances, eventTypeKey, forkEventContext, getClassKey, getConstructor, getContextInjector, getGlobalWooks, getHandlerPaths, getInfactScopeVars, getInfactSingletonInstances, getInstanceOwnMethods, getInstanceOwnProps, getMoostInfact, getMoostMate, getNewMoostInfact, globalKey, isConstructor, isThenable, key, loggerConsoleTransport, mergeSorted, registerEventScope, replaceContextInjector, resetContextInjector, resolvePipe, run, setControllerContext, setInfactLoggingOptions, setInterceptResult, setOvertake, stampModuleIdentity, stampOnce, useControllerContext, useHandlerPaths, useInterceptResult, useLogger, useOvertake, useScopeId, withControllerContext };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moost",
-  "version": "0.6.41",
+  "version": "0.6.43",
   "description": "moost",
   "keywords": [
     "composables",
@@ -41,15 +41,15 @@
     "@prostojs/infact": "^0.6.0",
     "@prostojs/logger": "^0.4.3",
     "@prostojs/mate": "^0.5.0",
-    "@wooksjs/event-core": "^0.7.24",
+    "@wooksjs/event-core": "^0.7.26",
     "hookable": "^5.5.3",
-    "wooks": "^0.7.24"
+    "wooks": "^0.7.26"
   },
   "devDependencies": {
-    "@wooksjs/event-http": "^0.7.24",
-    "@wooksjs/http-body": "^0.7.24",
+    "@wooksjs/event-http": "^0.7.26",
+    "@wooksjs/http-body": "^0.7.26",
     "vitest": "3.2.7",
-    "@moostjs/event-http": "^0.6.41"
+    "@moostjs/event-http": "^0.6.43"
   },
   "scripts": {
     "pub": "pnpm publish --access public",