navi-di 0.1.0

package/CODE_OF_CONDUCT.md

@@ -0,0 +1,20 @@
+# Code of Conduct
+
+## Our standard
+
+Please be respectful, specific, and constructive.
+
+We expect contributors to:
+
+- discuss technical disagreements in good faith;
+- focus feedback on code, design, and behavior rather than people;
+- avoid harassment, abuse, discrimination, and personal attacks; and
+- help keep the project welcoming to new contributors.
+
+## Enforcement
+
+Project maintainers may edit, hide, or remove content that violates this code of conduct and may restrict future participation when needed to protect the project.
+
+## Reporting
+
+Please report serious or repeated issues through the security contact listed in [SECURITY.md](./SECURITY.md).

package/CONTRIBUTING.md

@@ -0,0 +1,28 @@
+# Contributing
+
+Thank you for contributing to `navi-di`.
+
+## Scope
+
+This repository is focused on a small, explicit DI core for standard ECMAScript decorators. Please keep proposals aligned with that goal and avoid bundling unrelated framework abstractions into the base package.
+
+## Before you open a pull request
+
+1. Open or reference an issue when the change affects public API or package behavior.
+2. Keep changes narrowly scoped and explain the motivation.
+3. Update docs when user-facing behavior changes.
+
+## Git hooks
+
+This repository uses Lefthook.
+
+- `pre-commit` runs fast staged-file checks for lint and formatting.
+
+If hooks stop working locally, reinstall them with `bun run hooks:install`.
+
+## Pull request checklist
+
+- the change is focused and documented;
+- scripts in the local checks section pass;
+- package exports and Node compatibility were kept intact;
+- new behavior includes tests or a clear explanation for why tests are not needed.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Naviary Sanctuary
+
+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,283 @@
+# navi-di
+
+`navi-di` is a dependency injection library built for standard ECMAScript decorators.
+
+## Installation
+
+`navi-di` can be installed with any common JavaScript package manager:
+
+```sh
+npm install navi-di
+pnpm add navi-di
+yarn add navi-di
+bun add navi-di
+```
+
+The current implementation focuses on a compact core:
+
+- `@Service()` registers classes in the default container.
+- `@Inject()` wires decorated class fields from the active container.
+- `Container.of()` resolves services from the default container or from named containers.
+- `singleton`, `container`, and `transient` scopes control instance lifetime.
+- Circular graphs and missing services fail with explicit runtime errors.
+
+## What is implemented today
+
+The repository is no longer just scaffolding. The source and tests currently cover:
+
+- class registration through `@Service()`;
+- field injection through `@Inject()`;
+- named containers via `Container.of(id)`;
+- default-container fallback for named containers;
+- per-container caching for `container` scope;
+- shared instances for `singleton` scope;
+- fresh instances for `transient` scope;
+- cache reset and registration reset through `container.reset()`;
+- error handling for circular dependencies, missing services, and invalid container operations.
+
+## Requirements
+
+- Runtime target: Node.js `>=18.18`
+- Local development toolchain: Bun `>=1.3.0`
+- Language target: TypeScript 5 style standard decorators
+- Module format: ESM
+
+No environment variables or external services are required for local development.
+
+## Public entry points
+
+The package root currently exports:
+
+- `Container`
+- `Service`
+- `Inject`
+- `Constructable` / `AbstractConstructable`
+- `ServiceIdentifier`
+
+## Quick start
+
+```ts
+import { Container, Inject, Service } from 'navi-di';
+
+@Service()
+class LoggerService {
+  public log(message: string) {
+    console.log(message);
+  }
+}
+
+@Service()
+class HandlerService {
+  @Inject(LoggerService)
+  public logger!: LoggerService;
+}
+
+const handler = Container.of().get(HandlerService);
+
+handler.logger.log('hello from navi-di');
+```
+
+How resolution works:
+
+1. `@Service()` stores the class metadata in the default container.
+2. `@Inject()` records which decorated fields should be resolved.
+3. `Container.of().get(HandlerService)` creates `HandlerService`.
+4. The container resolves each injected field from the same container instance.
+
+## Service lifetimes
+
+`navi-di` currently supports three scopes.
+
+### `container`
+
+The default scope. One instance is cached per container.
+
+- repeated `get()` calls in the same container reuse the same instance;
+- named containers receive their own isolated instance;
+- named containers lazily clone container-scoped registrations from the default container on first access.
+
+### `singleton`
+
+One shared instance across all containers.
+
+- singleton registrations are effectively stored in the default container;
+- resolving the same singleton from a named container returns the same shared instance as the default container.
+
+### `transient`
+
+A new instance is created on every `get()` call.
+
+## Named containers
+
+Use named containers when you want isolated request, job, or unit-of-work state.
+
+```ts
+const requestA = Container.of('request-a');
+const requestB = Container.of('request-b');
+```
+
+Current behavior:
+
+- `Container.of()` and `Container.of('default')` return the same default container;
+- `Container.of('name')` reuses the same named container for the same id;
+- named containers fall back to registrations stored in the default container;
+- `container` scope becomes container-local after first resolution in a named container;
+- `singleton` scope stays shared across the whole registry.
+
+## Decorators
+
+### `@Service(options?)`
+
+Registers a class in the default container.
+
+Options supported today:
+
+- `id?: ServiceIdentifier`
+- `scope?: 'singleton' | 'container' | 'transient'`
+
+Example with a custom id:
+
+```ts
+import { Container, Service } from 'navi-di';
+
+@Service({ id: 'logger', scope: 'singleton' })
+class LoggerService {}
+
+const logger = Container.of().get('logger');
+```
+
+Note: a custom string id works for manual resolution through `container.get(...)`, but `@Inject()` currently accepts a constructable class dependency rather than an arbitrary token.
+
+### `@Inject(dependency)`
+
+Marks a decorated class field for property injection.
+
+Current characteristics:
+
+- injection is property-based, not constructor-based;
+- services are instantiated with `new Class()` and therefore must be resolvable without constructor arguments;
+- dependencies are resolved from the active container;
+- multiple decorated fields on the same class are supported;
+- injected fields are defined as writable and configurable own properties on the created instance;
+- injected fields are assigned after construction, so they are not available inside constructors or field initializers.
+
+## Container API
+
+### `Container.of(id?)`
+
+Returns the default container or a named container.
+
+### `container.get(id)`
+
+Resolves a service by class or service identifier.
+
+Throws:
+
+- `ServiceNotFoundError` when no registration exists;
+- `CircularDependencyError` when the current resolution path loops back to an in-progress dependency.
+
+### `container.has(id)`
+
+Checks whether the current container has a local registration.
+
+For named containers, this does not report default-container registrations until the service has been materialized locally.
+
+In practice, that means `has()` becomes `true` after first resolution for `container`-scoped services, but can remain `false` for `singleton` and `transient` services resolved through fallback.
+
+### `container.reset(strategy?)`
+
+Supported strategies:
+
+- `'value'` clears cached instances but keeps registrations;
+- `'service'` removes registrations from the current container.
+
+This is especially useful in tests.
+
+## Internal architecture
+
+The implementation is intentionally small and split into a few focused modules:
+
+- `src/decorators/` records decorator metadata for services and injected fields.
+- `src/container/container.ts` stores service metadata and performs resolution.
+- `src/container/registry.ts` owns the default container and named-container registry.
+- `src/types/` defines service identifiers, scopes, metadata, and injection metadata.
+- `src/errors/` provides explicit runtime error classes.
+- `test/` exercises registration, scoping, fallback behavior, reset behavior, and error paths.
+
+Resolution flow at a high level:
+
+1. decorators attach injection metadata through `context.metadata`;
+2. `@Service()` registers the class and its collected injections in the default container;
+3. `container.get()` loads registration metadata, handles scope rules, and creates the instance;
+4. each injected field is resolved recursively from the same container after instance construction;
+5. the container tracks the current resolution path to detect circular dependencies.
+
+## Development
+
+Install dependencies:
+
+```sh
+bun install
+```
+
+Available scripts:
+
+```sh
+bun run build
+bun run typecheck
+bun run test
+bun run lint
+bun run fmt
+bun run fmt:check
+bun run hooks:install
+bun run hooks:validate
+bun run hooks:run:pre-commit
+```
+
+What they do:
+
+- `build`: compile the package with `tsc -p tsconfig.build.json`
+- `typecheck`: run the TypeScript compiler in check mode
+- `test`: run Bun tests
+- `lint`: run `oxlint` with warnings denied
+- `fmt`: format the repository with `oxfmt`
+- `fmt:check`: verify formatting without writing changes
+- `hooks:*`: install, validate, or run the Lefthook-based Git hooks
+
+`bun install` also triggers `postinstall`, which installs the local Git hooks automatically.
+
+Current note: `typecheck` uses `tsconfig.json` with `noEmit: true`, while `build` uses `tsconfig.build.json` with `noEmit: false` to emit `dist/` and declaration files.
+
+## Local quality gates
+
+The repository currently enforces:
+
+- strict TypeScript checking;
+- `oxlint` for linting;
+- `oxfmt` for formatting;
+- Lefthook `pre-commit` checks for staged TypeScript, JavaScript, Markdown, YAML, and YML files.
+
+The package `prepack` script runs lint, format check, typecheck, and build before publishing.
+
+## Repository layout
+
+```text
+src/
+  container/
+  decorators/
+  errors/
+  types/
+test/
+dist/
+```
+
+- `src/` contains the library source.
+- `test/` contains Bun test coverage for the runtime behavior.
+- `dist/` contains the built ESM output and declaration files emitted by `tsconfig.build.json`.
+
+## Community
+
+- Contributing guide: [CONTRIBUTING.md](./CONTRIBUTING.md)
+- Code of Conduct: [CODE_OF_CONDUCT.md](./CODE_OF_CONDUCT.md)
+- Security policy: [SECURITY.md](./SECURITY.md)
+- License: [LICENSE](./LICENSE)

package/SECURITY.md

@@ -0,0 +1,23 @@
+# Security Policy
+
+## Supported versions
+
+Security fixes are applied to the latest development line first.
+
+| Version                   | Supported |
+| ------------------------- | --------- |
+| `0.x`                     | Yes       |
+| Earlier pre-release lines | No        |
+
+## Reporting a vulnerability
+
+Please report vulnerabilities through GitHub Security Advisories for this repository or contact the maintainers privately. Do not open a public issue for an unpatched security problem.
+
+## Scope notes
+
+Reports are especially helpful when they involve:
+
+- unexpected code execution through provider factories or container hooks;
+- token collisions or registry behavior that can resolve the wrong dependency;
+- metadata leaks that expose implementation details across package boundaries; or
+- denial-of-service style resolution loops that can be triggered by untrusted input.

package/dist/container/container.d.ts

@@ -0,0 +1,14 @@
+import type { ContainerIdentifier, Metadata, ServiceIdentifier } from '../types';
+export declare class Container {
+    readonly id: ContainerIdentifier;
+    private metadataMap;
+    private resolving;
+    private resolvingPath;
+    constructor(id: ContainerIdentifier);
+    static of(id?: ContainerIdentifier): Container;
+    set<T>(metadata: Metadata<T>): void;
+    has(id: ServiceIdentifier): boolean;
+    reset(strategy?: 'value' | 'service'): void;
+    get<T>(id: ServiceIdentifier<T>): T;
+    private isDefault;
+}

package/dist/container/container.js

@@ -0,0 +1,108 @@
+import { CircularDependencyError, ServiceNotFoundError } from '../errors';
+import { EMPTY_VALUE } from '../types';
+import { ContainerRegistry } from './registry';
+export class Container {
+    id;
+    metadataMap = new Map();
+    resolving = new Set();
+    resolvingPath = [];
+    constructor(id) {
+        this.id = id;
+    }
+    static of(id = 'default') {
+        if (id === 'default') {
+            return ContainerRegistry.defaultContainer;
+        }
+        if (ContainerRegistry.hasContainer(id)) {
+            return ContainerRegistry.getContainer(id);
+        }
+        const container = new Container(id);
+        ContainerRegistry.registerContainer(container);
+        return container;
+    }
+    set(metadata) {
+        if (metadata.scope === 'singleton' && !this.isDefault()) {
+            ContainerRegistry.defaultContainer.set(metadata);
+            this.metadataMap.delete(metadata.id);
+            return;
+        }
+        const newMetadata = {
+            ...metadata,
+        };
+        const existingMetadata = this.metadataMap.get(newMetadata.id);
+        if (existingMetadata) {
+            Object.assign(existingMetadata, newMetadata);
+        }
+        else {
+            this.metadataMap.set(newMetadata.id, newMetadata);
+        }
+    }
+    has(id) {
+        return this.metadataMap.has(id);
+    }
+    reset(strategy = 'value') {
+        if (strategy === 'value') {
+            this.metadataMap.forEach((metadata) => {
+                metadata.value = EMPTY_VALUE;
+            });
+        }
+        else {
+            this.metadataMap.clear();
+        }
+    }
+    get(id) {
+        let metadata = this.metadataMap.get(id);
+        if (!metadata && !this.isDefault()) {
+            const defaultMetadata = ContainerRegistry.defaultContainer.metadataMap.get(id);
+            if (!defaultMetadata) {
+                throw new ServiceNotFoundError(id);
+            }
+            if (defaultMetadata.scope === 'singleton') {
+                return ContainerRegistry.defaultContainer.get(id);
+            }
+            if (defaultMetadata.scope === 'container') {
+                metadata = {
+                    ...defaultMetadata,
+                    injections: [...defaultMetadata.injections],
+                    value: EMPTY_VALUE,
+                };
+                this.metadataMap.set(id, metadata);
+            }
+            else {
+                metadata = defaultMetadata;
+            }
+        }
+        if (!metadata) {
+            throw new ServiceNotFoundError(id);
+        }
+        if (metadata.scope !== 'transient' && metadata.value !== EMPTY_VALUE) {
+            return metadata.value;
+        }
+        if (this.resolving.has(id)) {
+            throw new CircularDependencyError([...this.resolvingPath, id]);
+        }
+        this.resolving.add(id);
+        this.resolvingPath.push(id);
+        try {
+            const instance = new metadata.Class();
+            for (const injection of metadata.injections) {
+                Object.defineProperty(instance, injection.name, {
+                    value: this.get(injection.id),
+                    writable: true,
+                    configurable: true,
+                });
+            }
+            if (metadata.scope !== 'transient') {
+                metadata.value = instance;
+            }
+            return instance;
+        }
+        finally {
+            this.resolving.delete(id);
+            this.resolvingPath.pop();
+        }
+    }
+    isDefault() {
+        return this === ContainerRegistry.defaultContainer;
+    }
+}

package/dist/container/index.d.ts

@@ -0,0 +1 @@
+export { Container } from './container';

package/dist/container/index.js

@@ -0,0 +1 @@
+export { Container } from './container';

package/dist/container/registry.d.ts

@@ -0,0 +1,11 @@
+import type { ContainerIdentifier } from '../types';
+import { Container } from './container';
+export declare class ContainerRegistry {
+    private static defaultContainerInstance?;
+    private static readonly containerMap;
+    static get defaultContainer(): Container;
+    static registerContainer(container: Container): void;
+    static getContainer(id: ContainerIdentifier): Container | undefined;
+    static hasContainer(id: ContainerIdentifier): boolean;
+    static removeContainer(id: ContainerIdentifier): void;
+}

package/dist/container/registry.js

@@ -0,0 +1,37 @@
+import { ContainerDuplicatedError, DefaultContainerIdError } from '../errors';
+import { Container } from './container';
+export class ContainerRegistry {
+    static defaultContainerInstance;
+    static containerMap = new Map();
+    static get defaultContainer() {
+        this.defaultContainerInstance ??= new Container('default');
+        return this.defaultContainerInstance;
+    }
+    static registerContainer(container) {
+        if (container.id === 'default') {
+            throw new DefaultContainerIdError();
+        }
+        if (ContainerRegistry.containerMap.has(container.id)) {
+            throw new ContainerDuplicatedError(container.id);
+        }
+        this.containerMap.set(container.id, container);
+    }
+    static getContainer(id) {
+        if (id === 'default') {
+            return this.defaultContainer;
+        }
+        return this.containerMap.get(id);
+    }
+    static hasContainer(id) {
+        if (id === 'default') {
+            return true;
+        }
+        return this.containerMap.has(id);
+    }
+    static removeContainer(id) {
+        if (id === 'default') {
+            throw new DefaultContainerIdError();
+        }
+        this.containerMap.delete(id);
+    }
+}

package/dist/decorators/index.d.ts

@@ -0,0 +1,2 @@
+export { Inject } from './inject';
+export { Service } from './service';

package/dist/decorators/index.js

@@ -0,0 +1,2 @@
+export { Inject } from './inject';
+export { Service } from './service';

package/dist/decorators/inject.d.ts

@@ -0,0 +1,2 @@
+import { type Constructable } from '../types';
+export declare function Inject<T>(dependency: Constructable<T>): (_: undefined, context: ClassFieldDecoratorContext) => void;

package/dist/decorators/inject.js

@@ -0,0 +1,10 @@
+import { INJECTION_KEY } from '../types';
+export function Inject(dependency) {
+    return function (_, context) {
+        const injections = (context.metadata[INJECTION_KEY] ??= []);
+        injections.push({
+            id: dependency,
+            name: context.name,
+        });
+    };
+}

package/dist/decorators/service.d.ts

@@ -0,0 +1,3 @@
+import type { ServiceOption } from '../types';
+export declare function Service(): Function;
+export declare function Service(options?: ServiceOption): Function;

package/dist/decorators/service.js

@@ -0,0 +1,15 @@
+import { ContainerRegistry } from '../container/registry';
+import { INJECTION_KEY, EMPTY_VALUE } from '../types';
+export function Service(options) {
+    return function (target, context) {
+        const injections = (context.metadata[INJECTION_KEY] ?? []);
+        ContainerRegistry.defaultContainer.set({
+            id: options?.id ?? target,
+            Class: target,
+            name: context.name,
+            injections,
+            scope: options?.scope ?? 'container',
+            value: EMPTY_VALUE,
+        });
+    };
+}

package/dist/errors/circular-dependency-error.d.ts

@@ -0,0 +1,5 @@
+import type { ServiceIdentifier } from '../types';
+export declare class CircularDependencyError extends Error {
+    name: string;
+    constructor(path: ServiceIdentifier[]);
+}

package/dist/errors/circular-dependency-error.js

@@ -0,0 +1,6 @@
+export class CircularDependencyError extends Error {
+    name = 'CircularDependencyError';
+    constructor(path) {
+        super(`Circular dependency detected: ${path.map(String).join(' -> ')}`);
+    }
+}

package/dist/errors/container-duplicated-error.d.ts

@@ -0,0 +1,5 @@
+import type { ContainerIdentifier } from '../types';
+export declare class ContainerDuplicatedError extends Error {
+    name: string;
+    constructor(id: ContainerIdentifier);
+}

package/dist/errors/container-duplicated-error.js

@@ -0,0 +1,6 @@
+export class ContainerDuplicatedError extends Error {
+    name = 'ContainerDuplicatedError';
+    constructor(id) {
+        super(`Cannot register container with same ID(${String(id)})`);
+    }
+}

package/dist/errors/default-container-id-error.d.ts

@@ -0,0 +1,4 @@
+export declare class DefaultContainerIdError extends Error {
+    name: string;
+    constructor();
+}

package/dist/errors/default-container-id-error.js

@@ -0,0 +1,6 @@
+export class DefaultContainerIdError extends Error {
+    name = 'DefaultContainerIdError';
+    constructor() {
+        super(`You cannot register a container with the "default" for ID`);
+    }
+}

package/dist/errors/index.d.ts

@@ -0,0 +1,4 @@
+export { CircularDependencyError } from './circular-dependency-error';
+export { ContainerDuplicatedError } from './container-duplicated-error';
+export { DefaultContainerIdError } from './default-container-id-error';
+export { ServiceNotFoundError } from './service-not-found-error';

package/dist/errors/index.js

@@ -0,0 +1,4 @@
+export { CircularDependencyError } from './circular-dependency-error';
+export { ContainerDuplicatedError } from './container-duplicated-error';
+export { DefaultContainerIdError } from './default-container-id-error';
+export { ServiceNotFoundError } from './service-not-found-error';

package/dist/errors/service-not-found-error.d.ts

@@ -0,0 +1,5 @@
+import type { ServiceIdentifier } from '../types';
+export declare class ServiceNotFoundError extends Error {
+    name: string;
+    constructor(id: ServiceIdentifier);
+}

package/dist/errors/service-not-found-error.js

@@ -0,0 +1,6 @@
+export class ServiceNotFoundError extends Error {
+    name = 'ServiceNotFoundError';
+    constructor(id) {
+        super(`Service not found: ${String(id)}`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { Container } from './container';
+export { Service, Inject } from './decorators';
+export type { AbstractConstructable, Constructable } from './types/constructable.ts';
+export type { ServiceIdentifier } from './types/service.ts';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { Container } from './container';
+export { Service, Inject } from './decorators';

package/dist/types/constructable.d.ts

@@ -0,0 +1,2 @@
+export type Constructable<T = object, Args extends unknown[] = never[]> = new (...args: Args) => T;
+export type AbstractConstructable<T = object, Args extends unknown[] = never[]> = abstract new (...args: Args) => T;

package/dist/types/container.d.ts

@@ -0,0 +1,13 @@
+import type { Constructable } from './constructable';
+import type { InjectionMetadata } from './injection';
+import type { ServiceIdentifier, ServiceScope } from './service';
+export type ContainerIdentifier = string | symbol;
+export declare const EMPTY_VALUE: unique symbol;
+export interface Metadata<T = unknown> {
+    id: ServiceIdentifier;
+    Class: Constructable<T>;
+    name?: string | symbol;
+    injections: InjectionMetadata[];
+    scope: ServiceScope;
+    value: T | typeof EMPTY_VALUE;
+}

package/dist/types/container.js

@@ -0,0 +1 @@
+export const EMPTY_VALUE = Symbol.for('EMPTY_VALUE');

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export type { AbstractConstructable, Constructable } from './constructable';
+export type { ServiceIdentifier, ServiceOption } from './service';
+export { type ContainerIdentifier, type Metadata, EMPTY_VALUE } from './container';
+export { type InjectionMetadata, INJECTION_KEY } from './injection';

package/dist/types/index.js

@@ -0,0 +1,2 @@
+export { EMPTY_VALUE } from './container';
+export { INJECTION_KEY } from './injection';

package/dist/types/injection.d.ts

@@ -0,0 +1,6 @@
+import type { ServiceIdentifier } from './service';
+export interface InjectionMetadata {
+    id: ServiceIdentifier;
+    name: string | symbol;
+}
+export declare const INJECTION_KEY: unique symbol;

package/dist/types/injection.js

@@ -0,0 +1 @@
+export const INJECTION_KEY = Symbol.for('navi-di:injections');

package/dist/types/service.d.ts

@@ -0,0 +1,7 @@
+import type { AbstractConstructable, Constructable } from './constructable';
+export type ServiceIdentifier<T = unknown, Args extends unknown[] = never[]> = Constructable<T, Args> | AbstractConstructable<T, Args> | CallableFunction | string;
+export type ServiceScope = 'singleton' | 'container' | 'transient';
+export interface ServiceOption {
+    id?: ServiceIdentifier;
+    scope?: ServiceScope;
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "navi-di",
+  "version": "0.1.0",
+  "description": "Dependency injection for standard ECMAScript decorators.",
+  "keywords": [
+    "bun",
+    "decorators",
+    "dependency-injection",
+    "di",
+    "ecmascript",
+    "node",
+    "typescript"
+  ],
+  "homepage": "https://github.com/Naviary-Sanctuary/navi-di#readme",
+  "bugs": {
+    "url": "https://github.com/Naviary-Sanctuary/navi-di/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Naviary-Sanctuary/navi-di.git"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CONTRIBUTING.md",
+    "SECURITY.md",
+    "CODE_OF_CONDUCT.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json",
+    "hooks:install": "lefthook install",
+    "hooks:validate": "lefthook validate",
+    "hooks:run:pre-commit": "lefthook run pre-commit --all-files --force",
+    "lint": "oxlint . --deny-warnings",
+    "fmt": "oxfmt --config .oxfmt.json .",
+    "fmt:check": "oxfmt --check --config .oxfmt.json .",
+    "postinstall": "lefthook install",
+    "prepack": "bun run lint && bun run fmt:check && bun run typecheck && bun run build",
+    "test": "bun test --pass-with-no-tests"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.11",
+    "lefthook": "^2.1.4",
+    "oxfmt": "^0.41.0",
+    "oxlint": "^1.56.0",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "bun": ">=1.3.0",
+    "node": ">=18.18"
+  },
+  "packageManager": "bun@1.3.10"
+}