@nmtjs/core 0.15.0-beta.1 → 0.15.0-beta.2

package/dist/constants.js

@@ -0,0 +1,9 @@
+export const kOptionalDependency = Symbol.for('neemata:OptionalDependencyKey');
+export const kInjectable = Symbol.for('neemata:InjectableKey');
+export const kLazyInjectable = Symbol.for('neemata:LazyInjectableKey');
+export const kValueInjectable = Symbol.for('neemata:ValueInjectableKey');
+export const kFactoryInjectable = Symbol.for('neemata:FactoryInjectableKey');
+export const kProvider = Symbol.for('neemata:ProviderKey');
+export const kPlugin = Symbol.for('neemata:PluginKey');
+export const kMetadata = Symbol.for('neemata:MetadataKey');
+export const kHook = Symbol.for('neemata:HookKey');

package/dist/container.js

@@ -0,0 +1,328 @@
+import assert from 'node:assert';
+import { tryCaptureStackTrace } from '@nmtjs/common';
+import { Scope } from "./enums.js";
+import { CoreInjectables, compareScope, createValueInjectable, getDepedencencyInjectable, isFactoryInjectable, isInjectable, isLazyInjectable, isOptionalInjectable, isValueInjectable, provide, } from "./injectables.js";
+export class Container {
+    runtime;
+    scope;
+    parent;
+    instances = new Map();
+    resolvers = new Map();
+    injectables = new Set();
+    dependants = new Map();
+    disposing = false;
+    constructor(runtime, scope = Scope.Global, parent) {
+        this.runtime = runtime;
+        this.scope = scope;
+        this.parent = parent;
+        if (scope === Scope.Transient) {
+            throw new Error('Invalid scope');
+        }
+        this.provide(CoreInjectables.inject, this.createInjectFunction());
+        this.provide(CoreInjectables.dispose, this.createDisposeFunction());
+    }
+    async initialize(injectables) {
+        const measurements = [];
+        const traverse = (dependencies) => {
+            for (const key in dependencies) {
+                const dependency = dependencies[key];
+                const injectable = getDepedencencyInjectable(dependency);
+                if (injectable.scope === this.scope) {
+                    this.injectables.add(injectable);
+                }
+                traverse(injectable.dependencies);
+            }
+        };
+        for (const dependant of injectables) {
+            traverse(dependant.dependencies);
+        }
+        await Promise.all([...this.injectables].map((injectable) => this.resolve(injectable, measurements)));
+        return measurements;
+    }
+    fork(scope) {
+        return new Container(this.runtime, scope, this);
+    }
+    find(scope) {
+        if (this.scope === scope) {
+            return this;
+        }
+        else {
+            return this.parent?.find(scope);
+        }
+    }
+    async [Symbol.asyncDispose]() {
+        await this.dispose();
+    }
+    async dispose() {
+        this.runtime.logger.trace('Disposing [%s] scope context...', this.scope);
+        // Prevent new resolutions during disposal
+        this.disposing = true;
+        // Get proper disposal order using topological sort
+        const disposalOrder = this.getDisposalOrder();
+        try {
+            // Dispose in the correct order
+            for (const injectable of disposalOrder) {
+                if (this.instances.has(injectable)) {
+                    await this.disposeInjectableInstances(injectable);
+                }
+            }
+        }
+        catch (error) {
+            this.runtime.logger.fatal({ error }, 'Potential memory leak: error during container disposal');
+        }
+        this.instances.clear();
+        this.injectables.clear();
+        this.resolvers.clear();
+        this.dependants.clear();
+        this.disposing = false;
+    }
+    containsWithinSelf(injectable) {
+        return this.instances.has(injectable) || this.resolvers.has(injectable);
+    }
+    contains(injectable) {
+        return (this.containsWithinSelf(injectable) ||
+            (this.parent?.contains(injectable) ?? false));
+    }
+    get(injectable) {
+        if (injectable.scope === Scope.Transient) {
+            throw new Error('Cannot get transient injectable directly');
+        }
+        if (this.instances.has(injectable)) {
+            return this.instances.get(injectable).at(0).public;
+        }
+        if (this.parent?.contains(injectable)) {
+            return this.parent.get(injectable);
+        }
+        throw new Error('No instance found');
+    }
+    resolve(injectable, measurements) {
+        return this.resolveInjectable(injectable, undefined, undefined, measurements);
+    }
+    async createContext(dependencies) {
+        return this.createInjectableContext(dependencies);
+    }
+    async provide(injectable, ...[value]) {
+        const injections = Array.isArray(injectable)
+            ? injectable
+            : [provide(injectable, value)];
+        await Promise.all(injections.map(async ({ token, value }) => {
+            if (compareScope(token.scope, '>', this.scope)) {
+                // TODO: more informative error
+                throw new Error('Invalid scope');
+            }
+            const _value = isInjectable(value) ? await this.resolve(value) : value;
+            this.instances.set(token, [
+                { private: _value, public: _value, context: undefined },
+            ]);
+        }));
+    }
+    satisfies(injectable) {
+        return compareScope(injectable.scope, '<=', this.scope);
+    }
+    async disposeInjectableInstances(injectable) {
+        try {
+            if (this.instances.has(injectable)) {
+                const wrappers = this.instances.get(injectable);
+                await Promise.all(wrappers.map((wrapper) => this.disposeInjectableInstance(injectable, wrapper.private, wrapper.context)));
+            }
+        }
+        catch (cause) {
+            const error = new Error('Injectable disposal error. Potential memory leak', { cause });
+            this.runtime.logger.error(error);
+        }
+        finally {
+            this.instances.delete(injectable);
+        }
+    }
+    async disposeInjectableInstance(injectable, instance, context) {
+        if (isFactoryInjectable(injectable)) {
+            const { dispose } = injectable;
+            if (dispose)
+                await dispose(instance, context);
+        }
+    }
+    async createInjectableContext(dependencies, dependant, measurements) {
+        const injections = {};
+        const deps = Object.entries(dependencies);
+        const resolvers = Array(deps.length);
+        for (let i = 0; i < deps.length; i++) {
+            const [key, dependency] = deps[i];
+            const isOptional = isOptionalInjectable(dependency);
+            const injectable = getDepedencencyInjectable(dependency);
+            const resolver = this.resolveInjectable(injectable, dependant, isOptional, measurements);
+            resolvers[i] = resolver.then((value) => (injections[key] = value));
+        }
+        await Promise.all(resolvers);
+        return Object.freeze(injections);
+    }
+    resolveInjectable(injectable, dependant, isOptional, measurements) {
+        if (this.disposing) {
+            return Promise.reject(new Error('Cannot resolve during disposal'));
+        }
+        if (dependant && compareScope(dependant.scope, '<', injectable.scope)) {
+            // TODO: more informative error
+            return Promise.reject(new Error('Invalid scope: dependant is looser than injectable'));
+        }
+        if (isValueInjectable(injectable)) {
+            return Promise.resolve(injectable.value);
+        }
+        else if (this.parent?.contains(injectable) ||
+            (this.parent?.satisfies(injectable) &&
+                compareScope(this.parent.scope, '<', this.scope))) {
+            return this.parent.resolveInjectable(injectable, dependant, undefined, measurements);
+        }
+        else {
+            const { stack, label } = injectable;
+            if (dependant) {
+                let dependants = this.dependants.get(injectable);
+                if (!dependants) {
+                    this.dependants.set(injectable, (dependants = new Set()));
+                }
+                dependants.add(dependant);
+            }
+            const isTransient = injectable.scope === Scope.Transient;
+            if (!isTransient && this.instances.has(injectable)) {
+                return Promise.resolve(this.instances.get(injectable).at(0).public);
+            }
+            else if (!isTransient && this.resolvers.has(injectable)) {
+                return this.resolvers.get(injectable);
+            }
+            else {
+                const isLazy = isLazyInjectable(injectable);
+                if (isLazy) {
+                    if (isOptional)
+                        return Promise.resolve(undefined);
+                    return Promise.reject(new Error(`No instance provided for ${label || 'an'} injectable:\n${stack}`));
+                }
+                else {
+                    const measure = measurements
+                        ? performance.measure(injectable.label || injectable.stack || '')
+                        : null;
+                    const resolution = this.createResolution(injectable, measurements).finally(() => {
+                        this.resolvers.delete(injectable);
+                        // biome-ignore lint: false
+                        // @ts-ignore
+                        if (measurements && measure)
+                            measurements.push(measure);
+                    });
+                    if (injectable.scope !== Scope.Transient) {
+                        this.resolvers.set(injectable, resolution);
+                    }
+                    return resolution;
+                }
+            }
+        }
+    }
+    async createResolution(injectable, measurements) {
+        const { dependencies } = injectable;
+        const context = await this.createInjectableContext(dependencies, injectable, measurements);
+        const wrapper = {
+            private: null,
+            public: null,
+            context,
+        };
+        if (isFactoryInjectable(injectable)) {
+            wrapper.private = await Promise.resolve(injectable.factory(wrapper.context));
+            wrapper.public = injectable.pick(wrapper.private);
+        }
+        else {
+            throw new Error('Invalid injectable type');
+        }
+        let instances = this.instances.get(injectable);
+        if (!instances) {
+            instances = [];
+            this.instances.set(injectable, instances);
+        }
+        instances.push(wrapper);
+        return wrapper.public;
+    }
+    createInjectFunction() {
+        const inject = (injectable, context, scope = this.scope) => {
+            const container = this.find(scope);
+            if (!container)
+                throw new Error('No container found for the specified scope');
+            const dependencies = { ...injectable.dependencies };
+            for (const key in context) {
+                const dep = context[key];
+                if (isInjectable(dep) || isOptionalInjectable(dep)) {
+                    dependencies[key] = dep;
+                }
+                else {
+                    dependencies[key] = createValueInjectable(dep);
+                }
+            }
+            const newInjectable = {
+                ...injectable,
+                dependencies,
+                scope: Scope.Transient,
+                stack: tryCaptureStackTrace(1),
+            };
+            return container.resolve(newInjectable);
+        };
+        const explicit = async (injectable, context, scope = this.scope) => {
+            if ('asyncDispose' in Symbol === false) {
+                throw new Error('Symbol.asyncDispose is not supported in this environment');
+            }
+            const container = this.find(scope);
+            if (!container)
+                throw new Error('No container found for the specified scope');
+            const instance = await inject(injectable, context);
+            const dispose = container.createDisposeFunction();
+            return {
+                instance,
+                [Symbol.asyncDispose]: async () => {
+                    await dispose(injectable, instance);
+                },
+            };
+        };
+        return Object.assign(inject, { explicit });
+    }
+    createDisposeFunction() {
+        return async (injectable, instance) => {
+            if (injectable.scope === Scope.Transient) {
+                assert(instance, 'Instance is required for transient injectable disposal');
+                const wrappers = this.instances.get(injectable);
+                if (wrappers) {
+                    for (const wrapper of wrappers) {
+                        if (wrapper.public === instance) {
+                            await this.disposeInjectableInstance(injectable, wrapper.private, wrapper.context);
+                            const index = wrappers.indexOf(wrapper);
+                            wrappers.splice(index, 1);
+                        }
+                    }
+                    if (wrappers.length === 0) {
+                        this.instances.delete(injectable);
+                    }
+                }
+            }
+            else {
+                await this.disposeInjectableInstances(injectable);
+            }
+        };
+    }
+    getDisposalOrder() {
+        const visited = new Set();
+        const result = [];
+        const visit = (injectable) => {
+            if (visited.has(injectable))
+                return;
+            visited.add(injectable);
+            const dependants = this.dependants.get(injectable);
+            if (dependants) {
+                for (const dependant of dependants) {
+                    if (this.instances.has(dependant)) {
+                        visit(dependant);
+                    }
+                }
+            }
+            // Only add to result if this container owns the instance
+            if (this.instances.has(injectable)) {
+                result.push(injectable);
+            }
+        };
+        for (const injectable of this.instances.keys()) {
+            visit(injectable);
+        }
+        return result;
+    }
+}

package/dist/enums.js

@@ -0,0 +1,7 @@
+export var Scope;
+(function (Scope) {
+    Scope["Global"] = "Global";
+    Scope["Connection"] = "Connection";
+    Scope["Call"] = "Call";
+    Scope["Transient"] = "Transient";
+})(Scope || (Scope = {}));

package/dist/hooks.js

@@ -0,0 +1,11 @@
+import { Hookable } from 'hookable';
+export class Hooks extends Hookable {
+    _;
+    createSignal(hook) {
+        const controller = new AbortController();
+        const unregister = this.hookOnce(String(hook), 
+        //@ts-expect-error
+        () => controller.abort());
+        return { controller, signal: controller.signal, unregister };
+    }
+}

package/dist/index.js

@@ -0,0 +1,13 @@
+// // biome-ignore lint/correctness/noUnusedImports: TSC wants it
+// // biome-ignore assist/source/organizeImports: TSC wants it
+// import {} from 'pino'
+export * from "./constants.js";
+export * from "./container.js";
+export * from "./enums.js";
+export * from "./hooks.js";
+export * from "./injectables.js";
+export * from "./logger.js";
+export * from "./metadata.js";
+export * from "./plugin.js";
+export * from "./types.js";
+export * from "./utils/index.js";

package/dist/injectables.js

@@ -0,0 +1,141 @@
+import { tryCaptureStackTrace } from '@nmtjs/common';
+import { kFactoryInjectable, kInjectable, kLazyInjectable, kOptionalDependency, kValueInjectable, } from "./constants.js";
+import { Scope } from "./enums.js";
+const ScopeStrictness = {
+    [Scope.Transient]: Number.NaN, // this should make it always fail to compare with other scopes
+    [Scope.Global]: 1,
+    [Scope.Connection]: 2,
+    [Scope.Call]: 3,
+};
+export const isLazyInjectable = (injectable) => injectable[kLazyInjectable];
+export const isFactoryInjectable = (injectable) => injectable[kFactoryInjectable];
+export const isValueInjectable = (injectable) => injectable[kValueInjectable];
+export const isInjectable = (injectable) => injectable[kInjectable];
+export const isOptionalInjectable = (injectable) => injectable[kOptionalDependency];
+export function getInjectableScope(injectable) {
+    let scope = injectable.scope;
+    const deps = injectable.dependencies;
+    for (const key in deps) {
+        const dependency = deps[key];
+        const injectable = getDepedencencyInjectable(dependency);
+        const dependencyScope = getInjectableScope(injectable);
+        if (dependencyScope !== Scope.Transient &&
+            scope !== Scope.Transient &&
+            compareScope(dependencyScope, '>', scope)) {
+            scope = dependencyScope;
+        }
+    }
+    return scope;
+}
+export function getDepedencencyInjectable(dependency) {
+    if (kOptionalDependency in dependency) {
+        return dependency.injectable;
+    }
+    return dependency;
+}
+export function createOptionalInjectable(injectable) {
+    return Object.freeze({
+        [kOptionalDependency]: true,
+        injectable,
+    });
+}
+export function createLazyInjectable(scope = Scope.Global, label, stackTraceDepth = 0) {
+    const injectable = Object.freeze({
+        scope,
+        dependencies: {},
+        label,
+        stack: tryCaptureStackTrace(stackTraceDepth),
+        optional: () => createOptionalInjectable(injectable),
+        $withType: () => injectable,
+        [kInjectable]: true,
+        [kLazyInjectable]: true,
+    });
+    return injectable;
+}
+export function createValueInjectable(value, label, stackTraceDepth = 0) {
+    return Object.freeze({
+        value,
+        scope: Scope.Global,
+        dependencies: {},
+        label,
+        stack: tryCaptureStackTrace(stackTraceDepth),
+        [kInjectable]: true,
+        [kValueInjectable]: true,
+    });
+}
+export function createFactoryInjectable(paramsOrFactory, label, stackTraceDepth = 0) {
+    const isFactory = typeof paramsOrFactory === 'function';
+    const params = isFactory ? { factory: paramsOrFactory } : paramsOrFactory;
+    const injectable = {
+        dependencies: (params.dependencies ?? {}),
+        scope: (params.scope ?? Scope.Global),
+        factory: params.factory,
+        dispose: params.dispose,
+        pick: params.pick ?? ((instance) => instance),
+        label,
+        stack: tryCaptureStackTrace(stackTraceDepth),
+        optional: () => createOptionalInjectable(injectable),
+        [kInjectable]: true,
+        [kFactoryInjectable]: true,
+    };
+    injectable.scope = resolveInjectableScope(typeof params.scope === 'undefined', injectable);
+    return Object.freeze(injectable);
+}
+export function substitute(injectable, substitution, stackTraceDepth = 0) {
+    const dependencies = { ...injectable.dependencies };
+    const depth = stackTraceDepth + 1;
+    for (const key in substitution) {
+        const value = substitution[key];
+        if (key in dependencies) {
+            const original = dependencies[key];
+            if (isInjectable(value)) {
+                dependencies[key] = value;
+            }
+            else if (isFactoryInjectable(original)) {
+                dependencies[key] = substitute(original, value, depth);
+            }
+        }
+    }
+    if (isFactoryInjectable(injectable)) {
+        // @ts-expect-error
+        return createFactoryInjectable({ ...injectable, dependencies }, injectable.label, depth);
+    }
+    throw new Error('Invalid injectable type');
+}
+export function compareScope(left, operator, right) {
+    const leftScope = ScopeStrictness[left];
+    const rightScope = ScopeStrictness[right];
+    switch (operator) {
+        case '=':
+            return leftScope === rightScope;
+        case '!=':
+            return leftScope !== rightScope;
+        case '>':
+            return leftScope > rightScope;
+        case '<':
+            return leftScope < rightScope;
+        case '>=':
+            return leftScope >= rightScope;
+        case '<=':
+            return leftScope <= rightScope;
+        default:
+            throw new Error('Invalid operator');
+    }
+}
+const logger = Object.assign((label) => createFactoryInjectable({
+    dependencies: { logger },
+    scope: Scope.Global,
+    factory: ({ logger }) => logger.child({ $label: label }),
+}), createLazyInjectable(Scope.Global, 'Logger'));
+const inject = createLazyInjectable(Scope.Global, 'Inject function');
+const dispose = createLazyInjectable(Scope.Global, 'Dispose function');
+function resolveInjectableScope(isDefaultScope, injectable) {
+    const actualScope = getInjectableScope(injectable);
+    if (!isDefaultScope && compareScope(actualScope, '>', injectable.scope))
+        throw new Error(`Invalid scope ${injectable.scope} for an injectable: dependencies have stricter scope - ${actualScope}`);
+    return actualScope;
+}
+export const CoreInjectables = { logger, inject, dispose };
+export const provide = (token, value) => {
+    return { token, value };
+};

package/dist/logger.js

@@ -0,0 +1,66 @@
+import { threadId } from 'node:worker_threads';
+import { pino, stdTimeFunctions } from 'pino';
+import { build as pretty } from 'pino-pretty';
+import { errWithCause } from 'pino-std-serializers';
+// TODO: use node:util inspect
+const bg = (value, color) => `\x1b[${color}m${value}\x1b[0m`;
+const fg = (value, color) => `\x1b[38;5;${color}m${value}\x1b[0m`;
+const levelColors = {
+    10: 100,
+    20: 102,
+    30: 106,
+    40: 104,
+    50: 101,
+    60: 105,
+    [Number.POSITIVE_INFINITY]: 0,
+};
+const messageColors = {
+    10: 0,
+    20: 2,
+    30: 6,
+    40: 4,
+    50: 1,
+    60: 5,
+    [Number.POSITIVE_INFINITY]: 0,
+};
+const levelLabels = {
+    10: ' TRACE ',
+    20: ' DEBUG ',
+    30: ' INFO  ',
+    40: ' WARN  ',
+    50: ' ERROR ',
+    60: ' FATAL ',
+    [Number.POSITIVE_INFINITY]: 'SILENT',
+};
+export const createLogger = (options = {}, $lable) => {
+    let { destinations, pinoOptions } = options;
+    if (!destinations || !destinations?.length) {
+        destinations = [
+            createConsolePrettyDestination((options.pinoOptions?.level || 'info')),
+        ];
+    }
+    const lowestLevelValue = destinations.reduce((acc, destination) => Math.min(acc, 'stream' in destination
+        ? pino.levels.values[destination.level]
+        : Number.POSITIVE_INFINITY), Number.POSITIVE_INFINITY);
+    const level = pino.levels.labels[lowestLevelValue];
+    const serializers = { ...pinoOptions?.serializers, err: errWithCause };
+    return pino({ timestamp: stdTimeFunctions.isoTime, ...pinoOptions, level, serializers }, pino.multistream(destinations)).child({ $lable, $threadId: threadId });
+};
+export const createConsolePrettyDestination = (level, sync = true) => ({
+    level,
+    stream: pretty({
+        colorize: true,
+        ignore: 'hostname,$lable,$threadId',
+        errorLikeObjectKeys: ['err', 'error', 'cause'],
+        messageFormat: (log, messageKey) => {
+            const group = fg(`[${log.$lable}]`, 11);
+            const msg = fg(log[messageKey], messageColors[log.level]);
+            const thread = fg(`(Thread-${log.$threadId})`, 89);
+            return `\x1b[0m${thread} ${group} ${msg}`;
+        },
+        customPrettifiers: {
+            level: (level) => bg(levelLabels[level], levelColors[level]),
+        },
+        sync,
+    }),
+});

package/dist/metadata.js

@@ -0,0 +1,15 @@
+import { kMetadata } from "./constants.js";
+export const createMetadataKey = (key) => {
+    const metadataKey = {
+        [kMetadata]: key,
+        as(value) {
+            return { key: metadataKey, value };
+        },
+    };
+    return metadataKey;
+};
+export class MetadataStore extends Map {
+    get(key) {
+        return super.get(key);
+    }
+}

package/dist/plugin.js

@@ -0,0 +1,3 @@
+import { kPlugin } from "./constants.js";
+export const createPlugin = (name, factory) => ({ name, factory, [kPlugin]: true });
+export const isPlugin = (value) => kPlugin in value;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/functions.js

@@ -0,0 +1,17 @@
+export { match } from '@nmtjs/common';
+export function isJsFile(name) {
+    if (name.endsWith('.d.ts'))
+        return false;
+    const leading = name.split('.').slice(1);
+    const ext = leading.join('.');
+    return ['js', 'mjs', 'cjs', 'ts', 'mts', 'cts'].includes(ext);
+}
+export function pick(obj, keys) {
+    const result = {};
+    for (const key in keys) {
+        if (key in obj) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+}

package/dist/utils/index.js

@@ -0,0 +1,3 @@
+export * from "./functions.js";
+export * from "./pool.js";
+export * from "./semaphore.js";

package/dist/utils/pool.js

@@ -0,0 +1,105 @@
+export class PoolError extends Error {
+}
+// Fixed pool from https://github.com/metarhia/metautil
+export class Pool {
+    options;
+    #items = [];
+    #free = [];
+    #queue = [];
+    #current = 0;
+    #size = 0;
+    #available = 0;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    add(item) {
+        if (this.#items.includes(item))
+            throw new PoolError('Item already exists');
+        this.#size++;
+        this.#available++;
+        this.#items.push(item);
+        this.#free.push(true);
+    }
+    remove(item) {
+        if (this.#size === 0)
+            throw new PoolError('Pool is empty');
+        const index = this.#items.indexOf(item);
+        if (index < 0)
+            throw new PoolError('Item is not in the pool');
+        const isCaptured = this.isFree(item);
+        if (isCaptured)
+            this.#available--;
+        this.#size--;
+        this.#current--;
+        this.#items.splice(index, 1);
+        this.#free.splice(index, 1);
+    }
+    capture(timeout = this.options.timeout) {
+        return this.next(true, timeout);
+    }
+    async next(exclusive = false, timeout = this.options.timeout) {
+        if (this.#size === 0)
+            throw new PoolError('Pool is empty');
+        if (this.#available === 0) {
+            return new Promise((resolve, reject) => {
+                const waiting = {
+                    resolve: (item) => {
+                        if (exclusive)
+                            this.#capture(item);
+                        resolve(item);
+                    },
+                    timer: undefined,
+                };
+                if (timeout) {
+                    waiting.timer = setTimeout(() => {
+                        waiting.resolve = undefined;
+                        this.#queue.shift();
+                        reject(new PoolError('Next item timeout'));
+                    }, timeout);
+                }
+                this.#queue.push(waiting);
+            });
+        }
+        let item;
+        let free = false;
+        do {
+            item = this.#items[this.#current];
+            free = this.#free[this.#current];
+            this.#current++;
+            if (this.#current >= this.#size)
+                this.#current = 0;
+        } while (typeof item === 'undefined' || !free);
+        if (exclusive)
+            this.#capture(item);
+        return item;
+    }
+    release(item) {
+        const index = this.#items.indexOf(item);
+        if (index < 0)
+            throw new PoolError('Unexpected item');
+        if (this.#free[index])
+            throw new PoolError('Unable to release not captured item');
+        this.#free[index] = true;
+        this.#available++;
+        if (this.#queue.length > 0) {
+            const { resolve, timer } = this.#queue.shift();
+            clearTimeout(timer);
+            if (resolve)
+                setTimeout(resolve, 0, item);
+        }
+    }
+    isFree(item) {
+        const index = this.#items.indexOf(item);
+        if (index < 0)
+            return false;
+        return this.#free[index];
+    }
+    get items() {
+        return [...this.#items];
+    }
+    #capture(item) {
+        const index = this.#items.indexOf(item);
+        this.#free[index] = false;
+        this.#available--;
+    }
+}

package/dist/utils/semaphore.js

@@ -0,0 +1,55 @@
+export class SemaphoreError extends Error {
+}
+// Semaphore from https://github.com/metarhia/metautil
+export class Semaphore {
+    size;
+    timeout;
+    counter;
+    queue = [];
+    constructor(concurrency, size = 0, timeout = 0) {
+        this.size = size;
+        this.timeout = timeout;
+        this.counter = concurrency;
+    }
+    enter() {
+        if (this.counter > 0) {
+            this.counter--;
+            return Promise.resolve();
+        }
+        else if (this.queue.length >= this.size) {
+            return Promise.reject(new SemaphoreError('Queue is full'));
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                const waiting = { resolve };
+                waiting.timer = setTimeout(() => {
+                    waiting.resolve = undefined;
+                    this.queue.shift();
+                    reject(new SemaphoreError('Timeout'));
+                }, this.timeout);
+                this.queue.push(waiting);
+            });
+        }
+    }
+    leave() {
+        if (this.queue.length === 0) {
+            this.counter++;
+        }
+        else {
+            const item = this.queue.shift();
+            if (item) {
+                const { resolve, timer } = item;
+                if (timer)
+                    clearTimeout(timer);
+                if (resolve)
+                    setTimeout(resolve, 0);
+            }
+        }
+    }
+    get isEmpty() {
+        return this.queue.length === 0;
+    }
+    get queueLength() {
+        return this.queue.length;
+    }
+}

package/package.json

@@ -8,15 +8,15 @@
   "peerDependencies": {
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0",
-    "@nmtjs/common": "0.15.0-beta.1",
-    "@nmtjs/type": "0.15.0-beta.1"
+    "@nmtjs/common": "0.15.0-beta.2",
+    "@nmtjs/type": "0.15.0-beta.2"
   },
   "devDependencies": {
     "@types/node": "^24",
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0",
-    "@nmtjs/common": "0.15.0-beta.1",
-    "@nmtjs/type": "0.15.0-beta.1"
+    "@nmtjs/common": "0.15.0-beta.2",
+    "@nmtjs/type": "0.15.0-beta.2"
   },
   "files": [
     "dist",
@@ -27,7 +27,7 @@
     "hookable": "6.0.0-rc.1",
     "pino-std-serializers": "^7.0.0"
   },
-  "version": "0.15.0-beta.1",
+  "version": "0.15.0-beta.2",
   "scripts": {
     "clean-build": "rm -rf ./dist",
     "build": "tsc",