@codefast/di 0.3.16-canary.0 → 0.3.16-canary.2

package/dist/container.mjs

@@ -1,11 +1,11 @@
 import { effectiveBindingScope } from "./binding-scope.mjs";
-import { DisposedContainerError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError } from "./errors.mjs";
-import { DEFAULT_SLOT, generateBindingId } from "./binding.mjs";
+import { AsyncModuleLoadError, CircularDependencyError, DisposedContainerError, InternalError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError } from "./errors.mjs";
+import { DEFAULT_BINDING_SLOT, generateBindingId } from "./binding.mjs";
 import { tokenName } from "./token.mjs";
 import { BindingRegistry } from "./registry.mjs";
 import { ScopeManager } from "./scope.mjs";
 import { LifecycleManager } from "./lifecycle.mjs";
-import { slotKeyToResolveOptions } from "./resolve-options.mjs";
+import { bindingSlotToResolveOptions, injectionSlotToResolveOptions } from "./resolve-options.mjs";
 import { DependencyResolver } from "./resolver.mjs";
 import { Inspector } from "./inspector.mjs";
 import { buildDependencyGraph } from "./dependency-graph.mjs";
@@ -53,7 +53,7 @@ var DefaultContainer = class DefaultContainer {
 	}
 	_createBindToBuilder(token, moduleRef) {
 		const registry = this._registry;
-		const commitBinding = (b, previousId) => {
+		const commitBinding = (binding, previousId) => {
 			if (previousId !== void 0) {
 				registry.removeById(previousId);
 				if (moduleRef !== void 0) {
@@ -64,18 +64,18 @@ var DefaultContainer = class DefaultContainer {
 					}
 				}
 			}
-			registry.add(b);
+			registry.add(binding);
 			if (moduleRef !== void 0) {
 				let ids = this._moduleBindingIds.get(moduleRef);
 				if (ids === void 0) {
 					ids = [];
 					this._moduleBindingIds.set(moduleRef, ids);
 				}
-				ids.push(b.id);
+				ids.push(binding.id);
 			}
-			return b.id;
+			return binding.id;
 		};
-		return new BindToBuilderImpl(token, commitBinding);
+		return new BindingEntry(token, commitBinding);
 	}
 	unbind(tokenOrId) {
 		this._assertNotDisposed();
@@ -130,8 +130,8 @@ var DefaultContainer = class DefaultContainer {
 	}
 	_getBindingsForTokenOrId(tokenOrId) {
 		if (typeof tokenOrId === "string") {
-			const b = this._registry.getById(tokenOrId);
-			return b !== void 0 ? [b] : [];
+			const binding = this._registry.getById(tokenOrId);
+			return binding !== void 0 ? [binding] : [];
 		}
 		return [...this._registry.getAll(tokenOrId)];
 	}
@@ -141,71 +141,72 @@ var DefaultContainer = class DefaultContainer {
 	}
 	_loadSyncModules(modules) {
 		const toLoad = this._collectModuleDeps(modules);
-		for (const mod of toLoad) {
-			const ref = mod;
-			const existing = this._moduleRefs.get(ref);
+		for (const module of toLoad) {
+			if (!isSyncModule(module)) throw new AsyncModuleLoadError(module.name);
+			const moduleRef = module;
+			const existing = this._moduleRefs.get(moduleRef);
 			if (existing !== void 0) {
-				this._moduleRefs.set(ref, existing + 1);
+				this._moduleRefs.set(moduleRef, existing + 1);
 				continue;
 			}
-			this._moduleRefs.set(ref, 1);
-			const builder = this._createModuleBuilder(ref);
-			mod._setup(builder);
+			this._moduleRefs.set(moduleRef, 1);
+			const builder = this._createModuleBuilder(moduleRef);
+			module._setup(builder);
 		}
 	}
 	_collectModuleDeps(modules) {
 		const seen = /* @__PURE__ */ new Set();
 		const result = [];
-		const visit = (mod) => {
-			const ref = mod;
-			if (seen.has(ref)) return;
-			seen.add(ref);
-			result.push(mod);
+		const visit = (module) => {
+			const moduleRef = module;
+			if (seen.has(moduleRef)) return;
+			seen.add(moduleRef);
+			result.push(module);
 		};
-		for (const m of modules) visit(m);
+		for (const module of modules) visit(module);
 		return result;
 	}
 	async loadAsync(...modules) {
 		this._assertNotDisposed();
-		for (const mod of modules) await this._loadOneModuleAsync(mod);
+		for (const module of modules) await this._loadOneModuleAsync(module);
 	}
-	async _loadOneModuleAsync(mod) {
-		const ref = mod;
-		const existing = this._moduleRefs.get(ref);
+	async _loadOneModuleAsync(module) {
+		const moduleRef = module;
+		const existing = this._moduleRefs.get(moduleRef);
 		if (existing !== void 0) {
-			this._moduleRefs.set(ref, existing + 1);
+			this._moduleRefs.set(moduleRef, existing + 1);
 			return;
 		}
-		this._moduleRefs.set(ref, 1);
-		if (isSyncModule(mod)) {
-			const builder = this._createModuleBuilder(ref);
-			mod._setup(builder);
+		this._moduleRefs.set(moduleRef, 1);
+		if (isSyncModule(module)) {
+			const builder = this._createModuleBuilder(moduleRef);
+			module._setup(builder);
 		} else {
 			const importPromises = [];
-			const builder = this._createAsyncModuleBuilder(ref, importPromises);
-			await mod._setup(builder);
+			const builder = this._createAsyncModuleBuilder(moduleRef, importPromises);
+			await module._setup(builder);
 			if (importPromises.length > 0) await Promise.all(importPromises);
 		}
 	}
 	_createModuleBuilder(moduleRef) {
 		return {
-			bind: (t) => this._createBindToBuilder(t, moduleRef),
-			import: (...mods) => {
-				this._loadSyncModules(mods);
+			bind: (token) => this._createBindToBuilder(token, moduleRef),
+			import: (...modules) => {
+				this._loadSyncModules(modules);
 			}
 		};
 	}
 	_createAsyncModuleBuilder(moduleRef, importPromises) {
 		return {
-			bind: (t) => this._createBindToBuilder(t, moduleRef),
-			import: (...mods) => {
-				for (const mod of mods) importPromises.push(this._loadOneModuleAsync(mod));
+			bind: (token) => this._createBindToBuilder(token, moduleRef),
+			import: (...modules) => {
+				for (const module of modules) importPromises.push(this._loadOneModuleAsync(module));
 			}
 		};
 	}
 	unload(...modules) {
 		this._assertNotDisposed();
-		for (const mod of modules) this._unloadModuleSync(mod);
+		for (const module of modules) this._unloadModuleSync(module);
 	}
 	_unloadModuleSync(ref) {
 		const count = this._moduleRefs.get(ref) ?? 0;
@@ -228,7 +229,7 @@ var DefaultContainer = class DefaultContainer {
 	}
 	async unloadAsync(...modules) {
 		this._assertNotDisposed();
-		for (const mod of modules) await this._unloadModuleAsync(mod);
+		for (const module of modules) await this._unloadModuleAsync(module);
 	}
 	async _unloadModuleAsync(ref) {
 		const count = this._moduleRefs.get(ref) ?? 0;
@@ -253,10 +254,10 @@ var DefaultContainer = class DefaultContainer {
 		this._assertNotDisposed();
 		const entries = registry.entries();
 		for (const { target, scope } of entries) {
-			const bb = this._createBindToBuilder(target).toSelf();
-			if (scope === "singleton") bb.singleton();
-			else if (scope === "scoped") bb.scoped();
-			else bb.transient();
+			const bindingBuilder = this._createBindToBuilder(target).toSelf();
+			if (scope === "singleton") bindingBuilder.singleton();
+			else if (scope === "scoped") bindingBuilder.scoped();
+			else bindingBuilder.transient();
 		}
 		return entries.length;
 	}
@@ -322,7 +323,7 @@ var DefaultContainer = class DefaultContainer {
 			if (effectiveBindingScope(binding) === "singleton" && !this._scope.hasSingleton(binding.id)) {
 				if (binding.predicate !== void 0) continue;
 				if (binding.kind === "constant" && binding.onActivation === void 0) continue;
-				const slotHint = slotKeyToResolveOptions(binding.slot);
+				const slotHint = bindingSlotToResolveOptions(binding.slot);
 				await this.resolveAsync(binding.token, slotHint);
 			}
 		}
@@ -332,43 +333,116 @@ var DefaultContainer = class DefaultContainer {
 		const reader = this._getMetadataReader();
 		const allBindings = this._registry.allBindings();
 		for (const binding of allBindings) {
-			if (binding.kind === "alias" || binding.kind === "constant" || binding.kind === "dynamic" || binding.kind === "dynamic-async") continue;
-			const scope = effectiveBindingScope(binding);
-			if (scope !== "singleton") continue;
-			const deps = this._getDepsForBinding(binding, reader);
-			for (const dep of deps) this._validateDep(tokenName(binding.token), scope, dep, [tokenName(binding.token)], reader);
+			if (!this._isSingletonStaticAnalyzableBinding(binding)) continue;
+			this._validateSingletonBindingGraph(binding, reader);
 		}
 	}
-	_getDepsForBinding(binding, reader) {
-		const result = [];
-		if (binding.kind === "class") {
-			const meta = reader.getConstructorMetadata(binding.target);
-			if (meta !== void 0) for (const param of meta.params) {
-				const depBindings = this._registry.getAll(param.token);
-				for (const db of depBindings) if (db.kind !== "alias") result.push({
-					token: param.token,
-					scope: effectiveBindingScope(db)
+	_isSingletonStaticAnalyzableBinding(binding) {
+		if (effectiveBindingScope(binding) !== "singleton") return false;
+		return binding.kind === "class" || binding.kind === "resolved" || binding.kind === "resolved-async";
+	}
+	/**
+	* DFS over explicit constructor / `toResolved*` dependency edges. Follows `toAlias` chains to the
+	* terminal binding for scope checks (SPEC §6.9). Skips `toDynamic*` subtrees (opaque).
+	*/
+	_validateSingletonBindingGraph(root, reader) {
+		const rootName = tokenName(root.token);
+		const dfs = (current, pathNames, pathBindingIds) => {
+			if (pathBindingIds.has(current.id)) return;
+			const extendedPathIds = new Set(pathBindingIds);
+			extendedPathIds.add(current.id);
+			for (const edge of this._collectStaticDependencyEdges(current, reader)) {
+				const { terminal, depTokenName } = edge;
+				const depScope = this._validationScopeFromTerminal(terminal);
+				if (depScope === "opaque") continue;
+				if (depScope === "scoped" || depScope === "transient") throw new ScopeViolationError({
+					consumerToken: rootName,
+					consumerScope: "singleton",
+					dependencyToken: depTokenName,
+					dependencyScope: depScope,
+					path: [...pathNames, depTokenName]
 				});
+				if (terminal.kind === "class" || terminal.kind === "resolved" || terminal.kind === "resolved-async") dfs(terminal, [...pathNames, depTokenName], extendedPathIds);
 			}
-		} else if (binding.kind === "resolved" || binding.kind === "resolved-async") for (const dep of binding.deps) {
-			const depBindings = this._registry.getAll(dep.token);
-			for (const db of depBindings) if (db.kind !== "alias") result.push({
-				token: dep.token,
-				scope: effectiveBindingScope(db)
-			});
+		};
+		dfs(root, [rootName], /* @__PURE__ */ new Set());
+	}
+	_validationScopeFromTerminal(terminal) {
+		switch (terminal.kind) {
+			case "constant": return "singleton";
+			case "dynamic":
+			case "dynamic-async": return "opaque";
+			case "class":
+			case "resolved":
+			case "resolved-async": return terminal.scope;
+			case "alias": throw new InternalError("validate: expected terminal binding after alias resolution");
+			default: return terminal;
 		}
-		return result;
 	}
-	_validateDep(consumerToken, consumerScope, dep, path, _reader) {
-		if (consumerScope === "singleton") {
-			if (dep.scope === "scoped" || dep.scope === "transient") throw new ScopeViolationError({
-				consumerToken,
-				consumerScope,
-				dependencyToken: tokenName(dep.token),
-				dependencyScope: dep.scope,
-				path
+	_followAliasChainToTerminal(binding, hint) {
+		const cyclePath = [];
+		const seenAliasIds = /* @__PURE__ */ new Set();
+		let current = binding;
+		while (current !== void 0 && current.kind === "alias") {
+			if (seenAliasIds.has(current.id)) throw new CircularDependencyError(cyclePath);
+			seenAliasIds.add(current.id);
+			cyclePath.push(tokenName(current.token));
+			const nextToken = current.target;
+			const next = this._resolver.peekBindingForValidate(nextToken, hint);
+			if (next === void 0) return;
+			current = next.binding;
+		}
+		return current;
+	}
+	_collectStaticDependencyEdges(binding, reader) {
+		const edges = [];
+		const pushTerminal = (terminal, displayName) => {
+			if (terminal === void 0) return;
+			edges.push({
+				terminal,
+				depTokenName: displayName
 			});
+		};
+		if (binding.kind === "class") {
+			const meta = reader.getConstructorMetadata(binding.target);
+			if (meta === void 0) return edges;
+			for (const param of meta.params) {
+				const paramHint = injectionSlotToResolveOptions(param);
+				if (param.optional) continue;
+				const tokenRef = param.token;
+				if (param.multi) {
+					const candidates = this._resolver.peekCandidateBindingsForValidate(tokenRef, paramHint);
+					for (const cand of candidates) {
+						const term = this._followAliasChainToTerminal(cand, paramHint);
+						pushTerminal(term, term !== void 0 ? tokenName(term.token) : "");
+					}
+					continue;
+				}
+				const found = paramHint === void 0 ? this._resolver.peekBindingForValidate(tokenRef, void 0) : this._resolver.peekBindingForValidate(tokenRef, paramHint);
+				if (found === void 0) continue;
+				const term = this._followAliasChainToTerminal(found.binding, paramHint);
+				pushTerminal(term, term !== void 0 ? tokenName(term.token) : "");
+			}
+			return edges;
 		}
+		if (binding.kind === "resolved" || binding.kind === "resolved-async") for (const dep of binding.deps) {
+			const depHint = injectionSlotToResolveOptions(dep);
+			if (dep.optional) continue;
+			const tokenRef = dep.token;
+			if (dep.multi) {
+				const candidates = this._resolver.peekCandidateBindingsForValidate(tokenRef, depHint);
+				for (const cand of candidates) {
+					const term = this._followAliasChainToTerminal(cand, depHint);
+					pushTerminal(term, term !== void 0 ? tokenName(term.token) : "");
+				}
+				continue;
+			}
+			const found = depHint === void 0 ? this._resolver.peekBindingForValidate(tokenRef, void 0) : this._resolver.peekBindingForValidate(tokenRef, depHint);
+			if (found === void 0) continue;
+			const term = this._followAliasChainToTerminal(found.binding, depHint);
+			pushTerminal(term, term !== void 0 ? tokenName(term.token) : "");
+		}
+		return edges;
 	}
 	has(token, hint) {
 		this._assertNotDisposed();
@@ -394,13 +468,25 @@ var DefaultContainer = class DefaultContainer {
 		if (this._disposed) throw new DisposedContainerError();
 	}
 };
-var BindToBuilderImpl = class {
+function updateSlotTag(slot, tag, value) {
+	const existing = [...slot.tags];
+	const idx = existing.findIndex(([k]) => k === tag);
+	if (idx !== -1) existing[idx] = [tag, value];
+	else existing.push([tag, value]);
+	return {
+		...slot,
+		tags: existing
+	};
+}
+var BindingEntry = class {
+	_token;
+	_commit;
 	constructor(_token, _commit) {
 		this._token = _token;
 		this._commit = _commit;
 	}
 	to(type) {
-		return new BindingBuilderImpl(this._token, {
+		return new ConstraintBuilder(this._token, {
 			kind: "class",
 			target: type,
 			scope: "transient"
@@ -408,32 +494,32 @@ var BindToBuilderImpl = class {
 	}
 	toSelf() {
 		if (typeof this._token !== "function") throw new Error("toSelf() requires token to be a Constructor");
-		return new BindingBuilderImpl(this._token, {
+		return new ConstraintBuilder(this._token, {
 			kind: "class",
 			target: this._token,
 			scope: "transient"
 		}, this._commit);
 	}
 	toConstantValue(value) {
-		return new ConstantBindingBuilderImpl(this._token, value, this._commit);
+		return new ConstantBuilder(this._token, value, this._commit);
 	}
 	toDynamic(factory) {
-		return new BindingBuilderImpl(this._token, {
+		return new ConstraintBuilder(this._token, {
 			kind: "dynamic",
 			factory,
 			scope: "transient"
 		}, this._commit);
 	}
 	toDynamicAsync(factory) {
-		return new BindingBuilderImpl(this._token, {
+		return new ConstraintBuilder(this._token, {
 			kind: "dynamic-async",
 			factory,
 			scope: "transient"
 		}, this._commit);
 	}
 	toResolved(factory, deps) {
-		const normalizedDeps = deps.map((d) => normalizeToDescriptor(d));
-		return new BindingBuilderImpl(this._token, {
+		const normalizedDeps = deps.map((dependency) => normalizeToDescriptor(dependency));
+		return new ConstraintBuilder(this._token, {
 			kind: "resolved",
 			factory,
 			deps: normalizedDeps,
@@ -441,8 +527,8 @@ var BindToBuilderImpl = class {
 		}, this._commit);
 	}
 	toResolvedAsync(factory, deps) {
-		const normalizedDeps = deps.map((d) => normalizeToDescriptor(d));
-		return new BindingBuilderImpl(this._token, {
+		const normalizedDeps = deps.map((dependency) => normalizeToDescriptor(dependency));
+		return new ConstraintBuilder(this._token, {
 			kind: "resolved-async",
 			factory,
 			deps: normalizedDeps,
@@ -450,10 +536,13 @@ var BindToBuilderImpl = class {
 		}, this._commit);
 	}
 	toAlias(target) {
-		return new AliasBindingBuilderImpl(this._token, target, this._commit);
+		return new AliasBuilder(this._token, target, this._commit);
 	}
 };
-var BindingBuilderImpl = class {
+var ConstraintBuilder = class {
+	_token;
+	_partial;
+	_commit;
 	_slot;
 	_predicate;
 	_committed;
@@ -462,7 +551,7 @@ var BindingBuilderImpl = class {
 		this._partial = _partial;
 		this._commit = _commit;
 		this._slot = {
-			...DEFAULT_SLOT,
+			...DEFAULT_BINDING_SLOT,
 			tags: []
 		};
 		this._doCommit();
@@ -492,14 +581,7 @@ var BindingBuilderImpl = class {
 		return this;
 	}
 	whenTagged(tag, value) {
-		const existing = [...this._slot.tags];
-		const idx = existing.findIndex(([k]) => k === tag);
-		if (idx !== -1) existing[idx] = [tag, value];
-		else existing.push([tag, value]);
-		this._slot = {
-			...this._slot,
-			tags: existing
-		};
+		this._slot = updateSlotTag(this._slot, tag, value);
 		this._doCommit();
 		return this;
 	}
@@ -509,7 +591,7 @@ var BindingBuilderImpl = class {
 	singleton() {
 		const previousId = this._committed;
 		this._committed = void 0;
-		return new ScopeBuilderImpl(this._token, {
+		return new ScopeBuilder(this._token, {
 			...this._partial,
 			scope: "singleton"
 		}, this._slot, this._predicate, this._commit, "singleton", previousId);
@@ -517,7 +599,7 @@ var BindingBuilderImpl = class {
 	transient() {
 		const previousId = this._committed;
 		this._committed = void 0;
-		return new ScopeBuilderImpl(this._token, {
+		return new ScopeBuilder(this._token, {
 			...this._partial,
 			scope: "transient"
 		}, this._slot, this._predicate, this._commit, "transient", previousId);
@@ -525,7 +607,7 @@ var BindingBuilderImpl = class {
 	scoped() {
 		const previousId = this._committed;
 		this._committed = void 0;
-		return new ScopeBuilderImpl(this._token, {
+		return new ScopeBuilder(this._token, {
 			...this._partial,
 			scope: "scoped"
 		}, this._slot, this._predicate, this._commit, "scoped", previousId);
@@ -534,7 +616,14 @@ var BindingBuilderImpl = class {
 		return this._committed;
 	}
 };
-var ScopeBuilderImpl = class {
+var ScopeBuilder = class {
+	_token;
+	_partial;
+	_slot;
+	_predicate;
+	_commit;
+	_scope;
+	_initialPreviousId;
 	_onActivation;
 	_onDeactivation;
 	_committed;
@@ -575,7 +664,10 @@ var ScopeBuilderImpl = class {
 		return this._committed;
 	}
 };
-var ConstantBindingBuilderImpl = class {
+var ConstantBuilder = class {
+	_token;
+	_value;
+	_commit;
 	_slot;
 	_predicate;
 	_onActivation;
@@ -586,7 +678,7 @@ var ConstantBindingBuilderImpl = class {
 		this._value = _value;
 		this._commit = _commit;
 		this._slot = {
-			...DEFAULT_SLOT,
+			...DEFAULT_BINDING_SLOT,
 			tags: []
 		};
 		this._doCommit();
@@ -620,14 +712,7 @@ var ConstantBindingBuilderImpl = class {
 		return this;
 	}
 	whenTagged(tag, value) {
-		const existing = [...this._slot.tags];
-		const idx = existing.findIndex(([k]) => k === tag);
-		if (idx !== -1) existing[idx] = [tag, value];
-		else existing.push([tag, value]);
-		this._slot = {
-			...this._slot,
-			tags: existing
-		};
+		this._slot = updateSlotTag(this._slot, tag, value);
 		this._doCommit();
 		return this;
 	}
@@ -648,7 +733,10 @@ var ConstantBindingBuilderImpl = class {
 		return this._committed;
 	}
 };
-var AliasBindingBuilderImpl = class {
+var AliasBuilder = class {
+	_token;
+	_target;
+	_commit;
 	_slot;
 	_predicate;
 	_committed;
@@ -657,7 +745,7 @@ var AliasBindingBuilderImpl = class {
 		this._target = _target;
 		this._commit = _commit;
 		this._slot = {
-			...DEFAULT_SLOT,
+			...DEFAULT_BINDING_SLOT,
 			tags: []
 		};
 		this._doCommit();
@@ -688,14 +776,7 @@ var AliasBindingBuilderImpl = class {
 		return this;
 	}
 	whenTagged(tag, value) {
-		const existing = [...this._slot.tags];
-		const idx = existing.findIndex(([k]) => k === tag);
-		if (idx !== -1) existing[idx] = [tag, value];
-		else existing.push([tag, value]);
-		this._slot = {
-			...this._slot,
-			tags: existing
-		};
+		this._slot = updateSlotTag(this._slot, tag, value);
 		this._doCommit();
 		return this;
 	}

package/dist/decorators/inject.d.mts

@@ -30,19 +30,19 @@ declare function isInjectionDescriptor(value: unknown): value is InjectionDescri
 /**
  * @since 0.3.16-canary.0
  */
-declare function normalizeToDescriptor(dep: InjectableDependency): InjectionDescriptor;
+declare function normalizeToDescriptor(dependency: InjectableDependency): InjectionDescriptor;
 type ClassAccessorDecorator<This, Value> = (target: ClassAccessorDecoratorTarget<This, Value>, context: ClassAccessorDecoratorContext<This, Value>) => ClassAccessorDecoratorResult<This, Value> | void;
 /**
  * @since 0.3.16-canary.0
  */
-declare function inject<const Value>(t: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value> & ClassAccessorDecorator<unknown, Value>;
+declare function inject<const Value>(token: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value> & ClassAccessorDecorator<unknown, Value>;
 /**
  * @since 0.3.16-canary.0
  */
-declare function optional<const Value>(t: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value | undefined>;
+declare function optional<const Value>(token: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value | undefined>;
 /**
  * @since 0.3.16-canary.0
  */
-declare function injectAll<const Value>(t: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value[]>;
+declare function injectAll<const Value>(token: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Array<Value>>;
 //#endregion
 export { InjectOptions, InjectableDependency, InjectionDescriptor, inject, injectAll, isInjectionDescriptor, normalizeToDescriptor, optional };