import { A as EmptyMeta, C as CUSTOM_INSTRUCTION_META, F as Simplify, I as StripEmpty, N as NormalizeMeta, O as Blocking, o as RunContext, t as Op, w as CustomInstruction } from "../index-BeplSvsa.mjs";

//#region src/di/types.d.ts
/** Binding failure when an injected dependency was not provided for the run. */
declare class MissingDependencyError extends Error {
  readonly name = "MissingDependencyError";
  readonly _tag = "MissingDependencyError";
  readonly key: string;
  constructor(key: string);
  static is(value: unknown): value is MissingDependencyError;
}
/** Binding failure when the same dependency token is provided more than once. */
declare class DuplicateDependencyError extends Error {
  readonly name = "DuplicateDependencyError";
  readonly _tag = "DuplicateDependencyError";
  readonly key: string;
  constructor(key: string);
  static is(value: unknown): value is DuplicateDependencyError;
}
declare const DI_TOKEN: unique symbol;
declare const DI_TAG = "DI";
declare const DI_SINGLETON_BINDING: unique symbol;
declare const DI_LAZY_BINDING: unique symbol;
type AnyDependency = Dependency<unknown, string>;
interface DependencyCtor<Name extends string> {
  readonly _tag: typeof DI_TAG;
  readonly key: Name;
  readonly [DI_TOKEN]: never;
  new <T>(): Dependency<T, Name>;
}
type DependencyValue<C, V = unknown> = C extends (abstract new (...args: never[]) => Dependency<infer T, string>) ? T & V : C extends Dependency<infer T, string> ? T & V : never;
type SingletonBinding<C extends AnyDependency, V = unknown> = {
  readonly [DI_SINGLETON_BINDING]: true;
  readonly dependency: C;
  readonly value: DependencyValue<C, V>;
};
type AnySingletonBinding = SingletonBinding<AnyDependency>;
type LazyResolveFn<C extends AnyDependency> = (signal: AbortSignal) => DependencyValue<C> | PromiseLike<DependencyValue<C>>;
type LazyBinding<C extends AnyDependency> = {
  readonly [DI_LAZY_BINDING]: true;
  readonly dependency: C;
  readonly resolve: LazyResolveFn<C>;
};
type AnyLazyBinding = LazyBinding<AnyDependency>;
type WithDIMeta<M, R> = [R] extends [never] ? NormalizeMeta<Omit<StripEmpty<M>, "deps">> : Simplify<Omit<StripEmpty<M>, "deps"> & {
  deps: Blocking<R>;
}>;
type RequiredDepsOfMeta<M> = M extends {
  deps: Blocking<infer Required>;
} ? Required : never;
/** Unsatisfied dependency tokens blocking `.run()` on an op. */
type RequiredDeps<C> = C extends Op<infer _T, infer _E, infer _A, infer M> ? RequiredDepsOfMeta<M> : never;
type Deps<C> = C extends (abstract new (...args: never[]) => infer I) ? I : C;
type AnyBinding = AnySingletonBinding | AnyLazyBinding;
type DepsOf<P extends AnyBinding> = P extends SingletonBinding<infer C> ? Deps<C> : P extends LazyBinding<infer C> ? Deps<C> : never;
type RemainingRequiredDeps<Entries extends readonly AnyBinding[], R> = Exclude<R, DepsOf<Entries[number]>>;
type ExcessProvidedDeps<Entries extends readonly AnyBinding[], R> = Exclude<DepsOf<Entries[number]>, R>;
type ValidProvideBindings<Bindings extends readonly AnyBinding[], R> = [ExcessProvidedDeps<Bindings, R>] extends [never] ? Bindings : never;
type UpdateProvidedMeta<M, R> = [R] extends [never] ? NormalizeMeta<Omit<StripEmpty<M>, "deps">> : Simplify<Omit<StripEmpty<M>, "deps"> & {
  deps: Blocking<R>;
}>;
type ProvidedMeta<M, Entries extends readonly AnyBinding[]> = UpdateProvidedMeta<M, RemainingRequiredDeps<Entries, RequiredDepsOfMeta<M>>>;
//#endregion
//#region src/di/plan.d.ts
declare class InjectInstruction<T, D> implements CustomInstruction<T, WithDIMeta<EmptyMeta, D>> {
  readonly _tag = "InjectInstruction";
  readonly [CUSTOM_INSTRUCTION_META]: WithDIMeta<EmptyMeta, D>;
  readonly dependency: AnyDependency;
  constructor(dependency: AnyDependency);
  resolve(context: RunContext<readonly unknown[]>): T | PromiseLike<T>;
  [Symbol.iterator](): Generator<this, T, unknown>;
}
//#endregion
//#region src/di/index.d.ts
/**
 * Phantom-typed dependency token created with {@link Dependency}.
 * Runtime slot identity is the token **class** passed to {@link inject} and bindings, not the
 * `key` string (see ADR 0010).
 */
interface Dependency<T, Name extends string> {
  readonly _tag: typeof DI_TAG;
  readonly key: Name;
  readonly [DI_TOKEN]: T;
}
/**
 * Creates a dependency token class for {@link inject} and bindings.
 * `key` is used in binding failure messages; two classes may share a `key` and remain distinct
 * slots.
 */
declare const Dependency: <const Name extends string>(key: Name) => DependencyCtor<Name>;
/** Yields a bound dependency value from the current run context. */
declare const inject: <C extends AnyDependency>(dependency: C) => Generator<InjectInstruction<DependencyValue<C>, Deps<C>>, DependencyValue<C>, unknown>;
/** Eager singleton binding for {@link provide}. */
declare const singleton: <C extends AnyDependency, V = unknown>(dependency: C, value: DependencyValue<C, V>) => SingletonBinding<C, V>;
/** Per-run lazy binding resolved when first injected. */
declare const scoped: <C extends AnyDependency>(dependency: C, resolve: LazyResolveFn<C>) => LazyBinding<C>;
/**
 * Satisfies dependency requirements on an op before `.run()`.
 * Pass a readonly tuple of `DI.singleton` / `DI.scoped` bindings
 */
declare const provide: <T, E, A, M, const Bindings extends readonly AnyBinding[]>(op: Op<T, E, A, M>, bindings: ValidProvideBindings<Bindings, RequiredDepsOfMeta<M>>) => Op<T, E, A, ProvidedMeta<M, Bindings>>;
/** Namespace object for dependency injection helpers. */
declare const DI: {
  readonly Dependency: <const Name extends string>(key: Name) => DependencyCtor<Name>;
  readonly inject: <C extends AnyDependency>(dependency: C) => Generator<InjectInstruction<DependencyValue<C>, Deps<C>>, DependencyValue<C>, unknown>;
  readonly singleton: <C extends AnyDependency, V = unknown>(dependency: C, value: DependencyValue<C, V>) => SingletonBinding<C, V>;
  readonly scoped: <C extends AnyDependency>(dependency: C, resolve: LazyResolveFn<C>) => LazyBinding<C>;
  readonly provide: <T, E, A, M, const Bindings extends readonly AnyBinding[]>(op: Op<T, E, A, M>, bindings: ValidProvideBindings<Bindings, RequiredDepsOfMeta<M>>) => Op<T, E, A, ProvidedMeta<M, Bindings>>; /** Error type for a missing binding on `error.cause` after `.run()`. */
  readonly MissingDependencyError: typeof MissingDependencyError; /** Error type for a duplicate binding on `error.cause` after `.run()`. */
  readonly DuplicateDependencyError: typeof DuplicateDependencyError;
};
//#endregion
export { DI, Dependency, type RequiredDeps, inject, provide, scoped, singleton };
//# sourceMappingURL=index.d.mts.map