@velajs/vela 0.2.1

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## 0.1.0 (2026-02-19)
+
+Initial release.
+
+- Decorator-based controllers with full HTTP method support
+- Dependency injection with singleton, transient, and request scopes
+- Module system with imports, exports, and dynamic modules
+- Guards, pipes, interceptors, exception filters, and middleware
+- Built-in pipes: ParseIntPipe, ParseFloatPipe, ParseBoolPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe
+- 18 built-in HTTP exceptions
+- Custom metadata with SetMetadata + Reflector
+- Custom parameter decorators via createParamDecorator
+- Route versioning
+- Global prefix support
+- Lifecycle hooks
+- Optional hono-crud integration via `vela/crud`
+- Edge runtime compatible (Cloudflare Workers, Deno, Bun, Node.js 20+)

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ksh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+# @velajs/vela
+
+NestJS-compatible framework for edge runtimes, powered by [Hono](https://hono.dev).
+
+## Install
+
+```bash
+npm install @velajs/vela
+# or
+bun add @velajs/vela
+```
+
+## Quick Start
+
+```typescript
+import { VelaFactory, Controller, Get, Module, Injectable } from '@velajs/vela';
+
+@Injectable()
+class AppService {
+  getHello() {
+    return { message: 'Hello from the edge!' };
+  }
+}
+
+@Controller('/app')
+class AppController {
+  constructor(private appService: AppService) {}
+
+  @Get('/')
+  hello() {
+    return this.appService.getHello();
+  }
+}
+
+@Module({
+  controllers: [AppController],
+  providers: [AppService],
+})
+class AppModule {}
+
+const app = await VelaFactory.create(AppModule);
+export default app; // Works on Cloudflare Workers, Deno, Bun, etc.
+```
+
+## Features
+
+- **Decorator-based controllers** — `@Controller`, `@Get`, `@Post`, `@Put`, `@Patch`, `@Delete`
+- **Dependency injection** — `@Injectable`, `@Inject`, `InjectionToken`, singleton/transient/request scopes
+- **Modules** — `@Module` with imports, exports, controllers, providers
+- **Guards** — `@UseGuards` with `CanActivate` interface
+- **Pipes** — `@UsePipes`, built-in `ParseIntPipe`, `ParseBoolPipe`, `ZodValidationPipe`, etc.
+- **Interceptors** — `@UseInterceptors` with `NestInterceptor` interface
+- **Exception filters** — `@UseFilters`, `@Catch`, built-in HTTP exceptions
+- **Middleware** — `@UseMiddleware` for Hono-native middleware
+- **Custom metadata** — `@SetMetadata` + `Reflector`
+- **Custom param decorators** — `createParamDecorator`
+- **Route versioning** — `@Controller({ version: '1' })` + `@Version('2')`
+- **Global prefix** — `app.setGlobalPrefix('/api')`
+- **Lifecycle hooks** — `OnModuleInit`, `OnApplicationBootstrap`, `OnModuleDestroy`
+- **CRUD integration** — Optional [`@velajs/crud`](https://github.com/velajs/crud) package
+
+## Edge Runtime Compatibility
+
+Vela runs on any runtime that supports the Web Standards API:
+
+- Cloudflare Workers
+- Deno Deploy
+- Bun
+- Node.js 20+
+- Vercel Edge Functions
+
+No Node.js-specific APIs (`node:fs`, `Buffer`, `process`) are used.
+
+## CRUD Module (Optional)
+
+```bash
+bun add @velajs/crud hono-crud @hono/zod-openapi zod
+```
+
+See [`@velajs/crud`](https://github.com/velajs/crud) for documentation.
+
+## License
+
+MIT

package/dist/application.d.ts

@@ -0,0 +1,44 @@
+import type { Hono } from 'hono';
+import type { Container } from './container/container';
+import type { Token } from './container/types';
+import type { RouteManager } from './http/route.manager';
+import type { FilterType, GuardType, InterceptorType, MiddlewareType, PipeType } from './registry/types';
+export declare class VelaApplication {
+    private readonly container;
+    private readonly routeManager;
+    private instances;
+    private honoApp;
+    private routesBuilt;
+    constructor(container: Container, routeManager: RouteManager);
+    /** Pre-build routes (handles async CRUD imports). Called by VelaFactory. */
+    initRoutes(): Promise<void>;
+    /**
+     * Rebuild routes. Call after registering global middleware/guards/etc.
+     * Not needed if you don't use useGlobalMiddleware() post-create.
+     */
+    rebuild(): Promise<void>;
+    private getApp;
+    get fetch(): Hono['fetch'];
+    getInstances(): unknown[];
+    getContainer(): Container;
+    setInstances(instances: unknown[]): void;
+    /**
+     * Set a global prefix for all routes (e.g. '/api').
+     * Must be called before getHonoApp()/fetch, or call rebuild() after.
+     */
+    setGlobalPrefix(prefix: string): this;
+    /**
+     * Register global middleware. Call rebuild() after if called post-create.
+     * Controller/method-level @UseMiddleware works without rebuild.
+     */
+    useGlobalMiddleware(...middleware: MiddlewareType[]): this;
+    useGlobalPipes(...pipes: PipeType[]): this;
+    useGlobalGuards(...guards: GuardType[]): this;
+    useGlobalInterceptors(...interceptors: InterceptorType[]): this;
+    useGlobalFilters(...filters: FilterType[]): this;
+    get<T>(token: Token<T>): T;
+    getHonoApp(): Hono;
+    callOnModuleInit(): Promise<void>;
+    callOnApplicationBootstrap(): Promise<void>;
+    close(signal?: string): Promise<void>;
+}

package/dist/application.js

@@ -0,0 +1,112 @@
+import { hasBeforeApplicationShutdown, hasOnApplicationBootstrap, hasOnApplicationShutdown, hasOnModuleDestroy, hasOnModuleInit } from "./lifecycle/index.js";
+export class VelaApplication {
+    container;
+    routeManager;
+    instances = [];
+    honoApp = null;
+    routesBuilt = false;
+    constructor(container, routeManager){
+        this.container = container;
+        this.routeManager = routeManager;
+    }
+    /** Pre-build routes (handles async CRUD imports). Called by VelaFactory. */ async initRoutes() {
+        this.honoApp = await this.routeManager.build();
+        this.routesBuilt = true;
+    }
+    /**
+   * Rebuild routes. Call after registering global middleware/guards/etc.
+   * Not needed if you don't use useGlobalMiddleware() post-create.
+   */ async rebuild() {
+        this.honoApp = await this.routeManager.build();
+        this.routesBuilt = true;
+    }
+    getApp() {
+        if (!this.honoApp) {
+            throw new Error('Routes not built. This should not happen — VelaFactory.create() builds routes automatically.');
+        }
+        return this.honoApp;
+    }
+    get fetch() {
+        return this.getApp().fetch;
+    }
+    getInstances() {
+        return this.instances;
+    }
+    getContainer() {
+        return this.container;
+    }
+    setInstances(instances) {
+        this.instances = instances;
+    }
+    /**
+   * Set a global prefix for all routes (e.g. '/api').
+   * Must be called before getHonoApp()/fetch, or call rebuild() after.
+   */ setGlobalPrefix(prefix) {
+        this.routeManager.setGlobalPrefix(prefix);
+        return this;
+    }
+    /**
+   * Register global middleware. Call rebuild() after if called post-create.
+   * Controller/method-level @UseMiddleware works without rebuild.
+   */ useGlobalMiddleware(...middleware) {
+        this.routeManager.useGlobalMiddleware(...middleware);
+        return this;
+    }
+    useGlobalPipes(...pipes) {
+        this.routeManager.useGlobalPipes(...pipes);
+        return this;
+    }
+    useGlobalGuards(...guards) {
+        this.routeManager.useGlobalGuards(...guards);
+        return this;
+    }
+    useGlobalInterceptors(...interceptors) {
+        this.routeManager.useGlobalInterceptors(...interceptors);
+        return this;
+    }
+    useGlobalFilters(...filters) {
+        this.routeManager.useGlobalFilters(...filters);
+        return this;
+    }
+    get(token) {
+        return this.container.resolve(token);
+    }
+    getHonoApp() {
+        return this.getApp();
+    }
+    // Lifecycle hooks
+    async callOnModuleInit() {
+        for (const instance of this.instances){
+            if (hasOnModuleInit(instance)) {
+                await instance.onModuleInit();
+            }
+        }
+    }
+    async callOnApplicationBootstrap() {
+        for (const instance of this.instances){
+            if (hasOnApplicationBootstrap(instance)) {
+                await instance.onApplicationBootstrap();
+            }
+        }
+    }
+    async close(signal) {
+        const reversed = [
+            ...this.instances
+        ].reverse();
+        for (const instance of reversed){
+            if (hasBeforeApplicationShutdown(instance)) {
+                await instance.beforeApplicationShutdown(signal);
+            }
+        }
+        for (const instance of reversed){
+            if (hasOnModuleDestroy(instance)) {
+                await instance.onModuleDestroy();
+            }
+        }
+        for (const instance of reversed){
+            if (hasOnApplicationShutdown(instance)) {
+                await instance.onApplicationShutdown(signal);
+            }
+        }
+    }
+}

package/dist/constants.d.ts

@@ -0,0 +1,35 @@
+export declare const METADATA_KEYS: {
+    readonly INJECTABLE: "vela:injectable";
+    readonly INJECT: "vela:inject";
+    readonly SCOPE: "vela:scope";
+    readonly MODULE: "vela:module";
+    readonly CONTROLLER: "vela:controller";
+    readonly ROUTES: "vela:routes";
+    readonly PARAMS: "vela:params";
+    readonly HTTP_CODE: "vela:http-code";
+    readonly RESPONSE_HEADERS: "vela:response-headers";
+    readonly REDIRECT: "vela:redirect";
+    readonly CATCH: "vela:catch";
+    readonly CRUD: "vela:crud";
+};
+export declare enum HttpMethod {
+    GET = "get",
+    POST = "post",
+    PUT = "put",
+    PATCH = "patch",
+    DELETE = "delete",
+    OPTIONS = "options",
+    HEAD = "head"
+}
+export declare enum ParamType {
+    BODY = "body",
+    QUERY = "query",
+    PARAM = "param",
+    HEADERS = "headers",
+    REQUEST = "request"
+}
+export declare enum Scope {
+    SINGLETON = "singleton",
+    TRANSIENT = "transient",
+    REQUEST = "request"
+}

package/dist/constants.js

@@ -0,0 +1,43 @@
+export const METADATA_KEYS = {
+    // DI
+    INJECTABLE: 'vela:injectable',
+    INJECT: 'vela:inject',
+    SCOPE: 'vela:scope',
+    // Module
+    MODULE: 'vela:module',
+    // HTTP
+    CONTROLLER: 'vela:controller',
+    ROUTES: 'vela:routes',
+    PARAMS: 'vela:params',
+    HTTP_CODE: 'vela:http-code',
+    RESPONSE_HEADERS: 'vela:response-headers',
+    REDIRECT: 'vela:redirect',
+    // Pipeline
+    CATCH: 'vela:catch',
+    // CRUD
+    CRUD: 'vela:crud'
+};
+export var HttpMethod = /*#__PURE__*/ function(HttpMethod) {
+    HttpMethod["GET"] = "get";
+    HttpMethod["POST"] = "post";
+    HttpMethod["PUT"] = "put";
+    HttpMethod["PATCH"] = "patch";
+    HttpMethod["DELETE"] = "delete";
+    HttpMethod["OPTIONS"] = "options";
+    HttpMethod["HEAD"] = "head";
+    return HttpMethod;
+}({});
+export var ParamType = /*#__PURE__*/ function(ParamType) {
+    ParamType["BODY"] = "body";
+    ParamType["QUERY"] = "query";
+    ParamType["PARAM"] = "param";
+    ParamType["HEADERS"] = "headers";
+    ParamType["REQUEST"] = "request";
+    return ParamType;
+}({});
+export var Scope = /*#__PURE__*/ function(Scope) {
+    Scope["SINGLETON"] = "singleton";
+    Scope["TRANSIENT"] = "transient";
+    Scope["REQUEST"] = "request";
+    return Scope;
+}({});

package/dist/container/container.d.ts

@@ -0,0 +1,25 @@
+import type { ProviderOptions, Token, Type } from './types';
+export declare class Container {
+    private providers;
+    private resolutionStack;
+    private parent;
+    private requestInstances;
+    register<T>(provider: Type<T> | ProviderOptions<T>): this;
+    private registerClass;
+    private registerOptions;
+    resolve<T>(token: Token<T>): T;
+    has(token: Token): boolean;
+    getTokens(): Token[];
+    /**
+     * Create a child container for request-scoped resolution.
+     * The child shares the parent's providers but caches REQUEST-scoped
+     * instances separately per child (per request).
+     */
+    createChild(): Container;
+    clear(): void;
+    private resolveRegistration;
+    private resolveClass;
+    private resolveFactory;
+    resolveAsync<T>(token: Token<T>): Promise<T>;
+    private tokenToString;
+}

package/dist/container/container.js

@@ -0,0 +1,195 @@
+import { Scope } from "../constants.js";
+import { getConstructorDependencies, getInjectMetadata, getScope, isInjectable } from "./decorators.js";
+import { InjectionToken } from "./types.js";
+export class Container {
+    providers = new Map();
+    resolutionStack = new Set();
+    parent = null;
+    requestInstances = new Map();
+    register(provider) {
+        if (typeof provider === 'function') {
+            this.registerClass(provider);
+        } else {
+            this.registerOptions(provider);
+        }
+        return this;
+    }
+    registerClass(target) {
+        if (!isInjectable(target)) {
+            console.warn(`Warning: ${target.name} is not decorated with @Injectable(). ` + `It will be registered but dependency resolution may not work correctly.`);
+        }
+        const scope = getScope(target);
+        this.providers.set(target, {
+            token: target,
+            scope,
+            useClass: target
+        });
+    }
+    registerOptions(options) {
+        const token = options.token;
+        if (!token) {
+            throw new Error('Provider registration requires a token');
+        }
+        const registration = {
+            token,
+            scope: options.scope ?? Scope.SINGLETON
+        };
+        if (options.useValue !== undefined) {
+            registration.useValue = options.useValue;
+            registration.instance = options.useValue;
+        } else if (options.useFactory) {
+            registration.useFactory = options.useFactory;
+            registration.inject = options.inject;
+        } else if (options.useExisting) {
+            registration.useExisting = options.useExisting;
+        } else if (typeof token === 'function') {
+            registration.useClass = token;
+        }
+        this.providers.set(token, registration);
+    }
+    resolve(token) {
+        const registration = this.providers.get(token);
+        if (!registration) {
+            if (typeof token === 'function') {
+                this.register(token);
+                return this.resolve(token);
+            }
+            if (token instanceof InjectionToken && token.options?.factory) {
+                this.register({
+                    token,
+                    useFactory: token.options.factory
+                });
+                return this.resolve(token);
+            }
+            throw new Error(`No provider found for token: ${this.tokenToString(token)}`);
+        }
+        return this.resolveRegistration(registration);
+    }
+    has(token) {
+        return this.providers.has(token);
+    }
+    getTokens() {
+        return Array.from(this.providers.keys());
+    }
+    /**
+   * Create a child container for request-scoped resolution.
+   * The child shares the parent's providers but caches REQUEST-scoped
+   * instances separately per child (per request).
+   */ createChild() {
+        const child = new Container();
+        child.parent = this;
+        child.providers = this.providers; // share provider registrations
+        return child;
+    }
+    clear() {
+        this.providers.clear();
+        this.resolutionStack.clear();
+        this.requestInstances.clear();
+    }
+    resolveRegistration(registration) {
+        if (registration.useValue !== undefined) {
+            return registration.useValue;
+        }
+        if (registration.useExisting) {
+            return this.resolve(registration.useExisting);
+        }
+        // Singleton: return cached from registration (shared across all containers)
+        if (registration.scope === Scope.SINGLETON && registration.instance !== undefined) {
+            return registration.instance;
+        }
+        // Request: return cached from this child's requestInstances
+        if (registration.scope === Scope.REQUEST) {
+            const cached = this.requestInstances.get(registration.token);
+            if (cached !== undefined) {
+                return cached;
+            }
+        }
+        if (this.resolutionStack.has(registration.token)) {
+            const chain = [
+                ...this.resolutionStack,
+                registration.token
+            ].map((t)=>this.tokenToString(t)).join(' -> ');
+            throw new Error(`Circular dependency detected: ${chain}`);
+        }
+        this.resolutionStack.add(registration.token);
+        try {
+            let instance;
+            if (registration.useFactory) {
+                instance = this.resolveFactory(registration);
+            } else if (registration.useClass) {
+                instance = this.resolveClass(registration.useClass);
+            } else {
+                throw new Error(`Invalid provider registration for: ${this.tokenToString(registration.token)}`);
+            }
+            if (registration.scope === Scope.SINGLETON) {
+                registration.instance = instance;
+            } else if (registration.scope === Scope.REQUEST) {
+                this.requestInstances.set(registration.token, instance);
+            }
+            return instance;
+        } finally{
+            this.resolutionStack.delete(registration.token);
+        }
+    }
+    resolveClass(target) {
+        const paramTypes = getConstructorDependencies(target);
+        const injectMetadata = getInjectMetadata(target);
+        const injectMap = new Map(injectMetadata.map((m)=>[
+                m.index,
+                m.token
+            ]));
+        const dependencies = paramTypes.map((paramType, index)=>{
+            const token = injectMap.get(index) ?? paramType;
+            if (!token || token === Object) {
+                throw new Error(`Cannot resolve dependency at index ${index} for ${target.name}. ` + `Parameter type is undefined or Object. ` + `Use @Inject() to specify the token explicitly.`);
+            }
+            return this.resolve(token);
+        });
+        return new target(...dependencies);
+    }
+    resolveFactory(registration) {
+        if (!registration.useFactory) {
+            throw new Error('Factory function is missing');
+        }
+        const dependencies = (registration.inject || []).map((token)=>this.resolve(token));
+        const result = registration.useFactory(...dependencies);
+        if (result instanceof Promise) {
+            throw new Error(`Async factory for ${this.tokenToString(registration.token)} returned a Promise. ` + `Use resolveAsync() for async providers.`);
+        }
+        return result;
+    }
+    async resolveAsync(token) {
+        const registration = this.providers.get(token);
+        if (!registration) {
+            if (typeof token === 'function') {
+                this.register(token);
+                return this.resolveAsync(token);
+            }
+            throw new Error(`No provider found for token: ${this.tokenToString(token)}`);
+        }
+        if (registration.useFactory) {
+            if (registration.scope === Scope.SINGLETON && registration.instance !== undefined) {
+                return registration.instance;
+            }
+            const dependencies = await Promise.all((registration.inject || []).map((t)=>this.resolveAsync(t)));
+            const instance = await registration.useFactory(...dependencies);
+            if (registration.scope === Scope.SINGLETON) {
+                registration.instance = instance;
+            }
+            return instance;
+        }
+        return this.resolve(token);
+    }
+    tokenToString(token) {
+        if (token instanceof InjectionToken) {
+            return token.toString();
+        }
+        if (typeof token === 'function') {
+            return token.name;
+        }
+        if (typeof token === 'symbol') {
+            return token.toString();
+        }
+        return String(token);
+    }
+}

package/dist/container/decorators.d.ts

@@ -0,0 +1,8 @@
+import { Scope } from '../constants';
+import type { InjectableOptions, InjectMetadata, Token } from './types';
+export declare function Injectable(options?: InjectableOptions): ClassDecorator;
+export declare function Inject(token: Token): ParameterDecorator;
+export declare function isInjectable(target: object): boolean;
+export declare function getScope(target: object): Scope;
+export declare function getConstructorDependencies(target: object): unknown[];
+export declare function getInjectMetadata(target: object): InjectMetadata[];

package/dist/container/decorators.js

@@ -0,0 +1,36 @@
+import { METADATA_KEYS, Scope } from "../constants.js";
+import { defineMetadata, getMetadata } from "../metadata.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+export function Injectable(options = {}) {
+    return (target)=>{
+        const { scope = Scope.SINGLETON } = options;
+        MetadataRegistry.markInjectable(target);
+        MetadataRegistry.setScope(target, scope);
+        // Keep WeakMap write for external package compat
+        defineMetadata(METADATA_KEYS.INJECTABLE, true, target);
+        defineMetadata(METADATA_KEYS.SCOPE, scope, target);
+    };
+}
+export function Inject(token) {
+    return (target, _propertyKey, parameterIndex)=>{
+        const existing = MetadataRegistry.getInjectTokens(target) ?? (getMetadata(METADATA_KEYS.INJECT, target) || []);
+        existing.push({
+            index: parameterIndex,
+            token
+        });
+        MetadataRegistry.setInjectTokens(target, existing);
+        defineMetadata(METADATA_KEYS.INJECT, existing, target);
+    };
+}
+export function isInjectable(target) {
+    return MetadataRegistry.hasInjectable(target) || getMetadata(METADATA_KEYS.INJECTABLE, target) === true;
+}
+export function getScope(target) {
+    return MetadataRegistry.getScope(target) ?? getMetadata(METADATA_KEYS.SCOPE, target) ?? Scope.SINGLETON;
+}
+export function getConstructorDependencies(target) {
+    return Reflect.getMetadata('design:paramtypes', target) || [];
+}
+export function getInjectMetadata(target) {
+    return MetadataRegistry.getInjectTokens(target) ?? (getMetadata(METADATA_KEYS.INJECT, target) || []);
+}

package/dist/container/index.d.ts

@@ -0,0 +1,4 @@
+export { Container } from './container';
+export { Injectable, Inject, isInjectable, getScope } from './decorators';
+export { InjectionToken } from './types';
+export type { Type, Token, InjectableOptions, InjectMetadata, ProviderOptions, ProviderRegistration, InjectionTokenOptions, } from './types';

package/dist/container/index.js

@@ -0,0 +1,3 @@
+export { Container } from "./container.js";
+export { Injectable, Inject, isInjectable, getScope } from "./decorators.js";
+export { InjectionToken } from "./types.js";

package/dist/container/types.d.ts

@@ -0,0 +1,37 @@
+import type { Scope } from '../constants';
+export type Type<T = any> = new (...args: any[]) => T;
+export interface InjectionTokenOptions<T> {
+    factory?: () => T;
+}
+export declare class InjectionToken<T = unknown> {
+    private readonly description;
+    readonly options?: InjectionTokenOptions<T> | undefined;
+    constructor(description: string, options?: InjectionTokenOptions<T> | undefined);
+    toString(): string;
+}
+export type Token<T = any> = Type<T> | InjectionToken<T> | string | symbol;
+export interface InjectableOptions {
+    scope?: Scope;
+}
+export interface InjectMetadata {
+    index: number;
+    token: Token;
+}
+export interface ProviderOptions<T = unknown> {
+    token?: Token<T>;
+    scope?: Scope;
+    useValue?: T;
+    useFactory?: (...args: any[]) => T | Promise<T>;
+    inject?: Token[];
+    useExisting?: Token<T>;
+}
+export interface ProviderRegistration<T = unknown> {
+    token: Token<T>;
+    scope: Scope;
+    instance?: T;
+    useValue?: T;
+    useFactory?: (...args: any[]) => T | Promise<T>;
+    useClass?: Type<T>;
+    inject?: Token[];
+    useExisting?: Token<T>;
+}