@loutrejs/loutre 0.5.0 → 0.6.0

package/dist/core/extension.d.ts

@@ -0,0 +1,107 @@
+import type { Diagnostic } from './diagnostic.js';
+import type { TokenLike } from './token.js';
+declare const runtimeCapabilityValue: unique symbol;
+declare const executionExtensionTypeInfo: unique symbol;
+export interface RuntimeCapability<TValue = unknown> {
+    readonly kind: 'runtime-capability';
+    readonly id: string;
+    readonly identity: symbol;
+    readonly [runtimeCapabilityValue]?: TValue;
+}
+export type RuntimeCapabilityValue<TCapability> = TCapability extends RuntimeCapability<infer TValue> ? TValue : never;
+export declare function runtimeCapability<TValue>(id: string): RuntimeCapability<TValue>;
+export interface RuntimeCapabilityBindings {
+    has(capability: RuntimeCapability<any>): boolean;
+    get<TValue>(capability: RuntimeCapability<TValue>): TValue;
+}
+export interface RuntimeCapabilityBinding<TValue = unknown> {
+    readonly capability: RuntimeCapability<TValue>;
+    readonly value: TValue;
+}
+export declare function bindRuntimeCapability<TValue>(capability: RuntimeCapability<TValue>, value: TValue): RuntimeCapabilityBinding<TValue>;
+export declare class RuntimeCapabilityRegistry implements RuntimeCapabilityBindings {
+    #private;
+    constructor(bindings?: Iterable<RuntimeCapabilityBinding>);
+    has(capability: RuntimeCapability<any>): boolean;
+    get<TValue>(capability: RuntimeCapability<TValue>): TValue;
+}
+export interface ExecutionLease {
+    readonly signal: AbortSignal;
+    abort(reason?: unknown): void;
+    complete(): void;
+}
+export interface ExecutionKernelRuntime {
+    beginExecution(): ExecutionLease;
+    resolve<TValue>(token: TokenLike<TValue>, source?: string): TValue;
+}
+export interface ExecutionExtensionDrainContext {
+    readonly timeoutMs: number;
+}
+export interface ExecutionExtensionRuntime {
+    drain?(context: ExecutionExtensionDrainContext): void | Promise<void>;
+    close?(): void | Promise<void>;
+}
+export interface ExecutionCompileContext {
+    readonly moduleId: string;
+    readonly definitionIndex: number;
+}
+export interface ExecutionContribution<TCompiled = unknown> {
+    readonly kind: 'execution';
+    readonly id: string;
+    readonly executionKind: string;
+    readonly dependencies: readonly TokenLike[];
+    readonly capabilities: readonly RuntimeCapability[];
+    readonly compiled: TCompiled;
+}
+export interface ExecutionExtensionValidationContext<TCompiled = unknown> {
+    readonly executions: readonly ExecutionContribution<TCompiled>[];
+}
+export interface ExecutionProjectionContext<TCompiled = unknown> {
+    readonly execution: ExecutionContribution<TCompiled>;
+}
+export interface ExecutionExtensionRuntimeContext<TCompiled = unknown> {
+    readonly executions: readonly ExecutionContribution<TCompiled>[];
+    readonly capabilities: RuntimeCapabilityBindings;
+    readonly applicationRuntime: ExecutionKernelRuntime;
+}
+export interface HostExtensionContext<TCompiled = unknown, TRuntime extends ExecutionExtensionRuntime = ExecutionExtensionRuntime> {
+    readonly executions: readonly ExecutionContribution<TCompiled>[];
+    readonly runtime: TRuntime;
+    readonly applicationRuntime: ExecutionKernelRuntime;
+}
+export interface HostExtension<TNamespace extends string = string, TApi extends object = object, TCompiled = unknown, TRuntime extends ExecutionExtensionRuntime = ExecutionExtensionRuntime> {
+    readonly namespace: TNamespace;
+    create(context: HostExtensionContext<TCompiled, TRuntime>): TApi;
+}
+export interface ExecutionExtension<TDefinition extends ExecutionDefinition<any> = ExecutionDefinition<any>, TCompiled = unknown, TNamespace extends string = string, THostApi extends object = object, TRuntime extends ExecutionExtensionRuntime = ExecutionExtensionRuntime> {
+    readonly kind: 'execution-extension';
+    readonly name: string;
+    readonly abiVersion: string;
+    readonly identity: symbol;
+    readonly [executionExtensionTypeInfo]?: readonly [TNamespace, THostApi];
+    compile(definition: TDefinition, context: ExecutionCompileContext): ExecutionContribution<TCompiled>;
+    references?(definition: TDefinition): readonly ExecutionDefinition[];
+    validate?(context: ExecutionExtensionValidationContext<TCompiled>): readonly Diagnostic[];
+    createRuntime(context: ExecutionExtensionRuntimeContext<TCompiled>): TRuntime | Promise<TRuntime>;
+    projectGraph?(context: ExecutionProjectionContext<TCompiled>): unknown;
+    readonly host?: HostExtension<TNamespace, THostApi, TCompiled, TRuntime>;
+}
+export declare function defineExecutionExtension<const TDefinition extends ExecutionDefinition, TCompiled, const TNamespace extends string = never, THostApi extends object = {}, TRuntime extends ExecutionExtensionRuntime = ExecutionExtensionRuntime>(extension: Omit<ExecutionExtension<TDefinition, TCompiled, TNamespace, THostApi, TRuntime>, 'identity'>): ExecutionExtension<TDefinition, TCompiled, TNamespace, THostApi, TRuntime>;
+export declare const executionDefinitionBrand: unique symbol;
+export interface ExecutionDefinition<TExtension extends AnyExecutionExtension = AnyExecutionExtension> {
+    readonly kind: 'execution-definition';
+    readonly extension: TExtension;
+    readonly [executionDefinitionBrand]: true;
+}
+export declare function defineExecution<const TExtension extends ExecutionExtension, const TDefinition extends object>(extension: TExtension, definition: TDefinition): Readonly<TDefinition & ExecutionDefinition<TExtension>>;
+export declare function isExecutionDefinition(value: unknown): value is ExecutionDefinition;
+export type ExtensionOfDefinition<TDefinition> = TDefinition extends {
+    readonly extension: infer TExtension extends AnyExecutionExtension;
+} ? TExtension : never;
+export type AnyExecutionExtension = ExecutionExtension<any, any, any, any, any>;
+export type HostApiOfExtension<TExtension> = TExtension extends {
+    readonly host?: infer THost;
+} ? NonNullable<THost> extends HostExtension<infer TNamespace, infer THostApi, any, any> ? [TNamespace] extends [never] ? {} : {
+    readonly [K in TNamespace]: THostApi;
+} : {} : {};
+export {};

package/dist/core/extension.js

@@ -0,0 +1,73 @@
+const executionExtensionIdentityNamespace = 'loutre.execution-extension:';
+const runtimeCapabilityIdentityNamespace = 'loutre.runtime-capability:';
+export function runtimeCapability(id) {
+    if (id.trim().length === 0) {
+        throw new Error('LUTRE_CAPABILITY_ID: Capability id must not be empty.');
+    }
+    return Object.freeze({
+        kind: 'runtime-capability',
+        id,
+        identity: Symbol.for(`${runtimeCapabilityIdentityNamespace}${id}`),
+    });
+}
+export function bindRuntimeCapability(capability, value) {
+    return Object.freeze({ capability, value });
+}
+export class RuntimeCapabilityRegistry {
+    #values = new Map();
+    #capabilities = new Map();
+    constructor(bindings = []) {
+        for (const binding of bindings) {
+            const identity = binding.capability.identity;
+            const existing = this.#capabilities.get(identity);
+            if (existing && existing.id !== binding.capability.id) {
+                throw new Error(`LUTRE_CAPABILITY_ID_COLLISION: ${binding.capability.id}`);
+            }
+            if (this.#values.has(identity)) {
+                throw new Error(`LUTRE_CAPABILITY_DUPLICATE_BINDING: ${binding.capability.id}`);
+            }
+            this.#capabilities.set(identity, binding.capability);
+            this.#values.set(identity, binding.value);
+        }
+    }
+    has(capability) {
+        return this.#values.has(capability.identity);
+    }
+    get(capability) {
+        if (!this.#values.has(capability.identity)) {
+            throw new Error(`LUTRE_CAPABILITY_MISSING: ${capability.id}`);
+        }
+        return this.#values.get(capability.identity);
+    }
+}
+function executionExtensionIdentity(name, abiVersion) {
+    return Symbol.for(`${executionExtensionIdentityNamespace}${JSON.stringify([name, abiVersion])}`);
+}
+export function defineExecutionExtension(extension) {
+    if (extension.abiVersion.trim().length === 0) {
+        throw new Error('LUTRE_EXTENSION_ABI_VERSION: Extension abiVersion must not be empty.');
+    }
+    return Object.freeze({
+        ...extension,
+        ...(extension.host === undefined
+            ? {}
+            : { host: Object.freeze({ ...extension.host }) }),
+        identity: executionExtensionIdentity(extension.name, extension.abiVersion),
+    });
+}
+export const executionDefinitionBrand = Symbol.for('loutre.execution-definition');
+export function defineExecution(extension, definition) {
+    return Object.freeze({
+        ...definition,
+        kind: 'execution-definition',
+        extension,
+        [executionDefinitionBrand]: true,
+    });
+}
+export function isExecutionDefinition(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value.kind === 'execution-definition' &&
+        executionDefinitionBrand in value &&
+        value[executionDefinitionBrand] === true);
+}

package/dist/core/generic-layer.d.ts

@@ -0,0 +1,26 @@
+import type { RuntimeCapability } from './extension.js';
+import type { TokenLike } from './token.js';
+import type { Type } from './type.js';
+export interface GenericLayerContext<TState extends object = {}> {
+    readonly state: Readonly<TState>;
+}
+export type GenericLayerNext<TContribution extends object> = keyof TContribution extends never ? () => Promise<void> : (contribution: TContribution) => Promise<void>;
+export interface GenericLayer<TContext extends object = object, TContribution extends object = {}, TOutcome = unknown> {
+    readonly kind: 'generic-layer';
+    readonly state?: Type<TContribution>;
+    readonly name: string;
+    readonly capabilities: readonly RuntimeCapability[];
+    readonly factory: () => (context: TContext & GenericLayerContext, next: GenericLayerNext<TContribution>) => Promise<void | TOutcome>;
+}
+export declare function defineLayer<TContribution extends object = {}, TContext extends object = object, TOutcome = never>(declaration: {
+    readonly name: string;
+    readonly state?: Type<TContribution>;
+    readonly capabilities?: readonly RuntimeCapability[];
+    readonly factory: GenericLayer<TContext, TContribution, TOutcome>['factory'];
+}): GenericLayer<TContext, TContribution, TOutcome>;
+export declare function composeLayers<TContext extends object, TOutcome>(options: {
+    readonly context: TContext;
+    readonly layers: readonly GenericLayer<any, any, TOutcome>[];
+    readonly resolve: <TValue>(token: TokenLike<TValue>, source?: string) => TValue;
+    readonly terminal: (context: TContext & GenericLayerContext<Record<string, unknown>>) => Promise<TOutcome>;
+}): Promise<TOutcome>;

package/dist/core/generic-layer.js

@@ -0,0 +1,116 @@
+import { runInInjectionContext } from './injection.js';
+export function defineLayer(declaration) {
+    return Object.freeze({
+        kind: 'generic-layer',
+        ...(declaration.state === undefined ? {} : { state: declaration.state }),
+        name: declaration.name,
+        capabilities: declaration.capabilities ?? [],
+        factory: declaration.factory,
+    });
+}
+export function composeLayers(options) {
+    const runtimes = options.layers.map((layer, index) => runInInjectionContext({
+        consumer: {
+            kind: 'layer',
+            id: `layer:${index}:${layer.name}`,
+            name: layer.name,
+        },
+        resolve: (token) => options.resolve(token, layer.name),
+    }, () => layer.factory()));
+    const dispatch = async (index, state) => {
+        const context = Object.assign(Object.create(options.context), {
+            state: Object.freeze({ ...state }),
+        });
+        const runtime = runtimes[index];
+        if (!runtime)
+            return options.terminal(context);
+        let called = false;
+        let continuationCompleted = false;
+        let continuationResult;
+        let continuationObserved = false;
+        let continuation;
+        const runtimeResult = await runtime(context, ((contribution = {}) => {
+            if (called) {
+                return Promise.reject(new Error('LUTRE_LAYER_NEXT_MULTIPLE: next() can be called once.'));
+            }
+            called = true;
+            continuation = dispatch(index + 1, mergeStateContribution(options.layers[index].name, state, contribution)).then((result) => {
+                continuationResult = result;
+                continuationCompleted = true;
+            });
+            return observePromise(continuation, () => {
+                continuationObserved = true;
+            });
+        }));
+        if (called && (!continuationObserved || !continuationCompleted)) {
+            const error = new Error(`LUTRE_LAYER_NEXT_NOT_AWAITED: Layer ${options.layers[index].name} must await or return next().`);
+            try {
+                await continuation;
+            }
+            catch (downstreamError) {
+                throw new AggregateError([error, downstreamError], error.message, {
+                    cause: downstreamError,
+                });
+            }
+            throw error;
+        }
+        if (called && continuationCompleted) {
+            return continuationResult;
+        }
+        return runtimeResult;
+    };
+    return dispatch(0, {});
+}
+function observePromise(promise, observe) {
+    const observed = {
+        // `await next()`の観測にはnative Promiseではなくthenable境界が必要になる。
+        // eslint-disable-next-line unicorn/no-thenable
+        then(onfulfilled, onrejected) {
+            observe();
+            return promise.then(onfulfilled, onrejected);
+        },
+        catch(onrejected) {
+            observe();
+            return promise.catch(onrejected);
+        },
+        finally(onfinally) {
+            observe();
+            return promise.finally(onfinally ?? undefined);
+        },
+        [Symbol.toStringTag]: 'Promise',
+    };
+    return observed;
+}
+function mergeStateContribution(layerName, state, contribution) {
+    if (!isPlainObject(contribution)) {
+        throw new Error(`LUTRE_LAYER_STATE_INVALID: Layer ${layerName} must pass a plain State contribution to next().`);
+    }
+    const nextState = { ...state };
+    for (const [namespace, payload] of Object.entries(contribution)) {
+        if (namespace === '__proto__') {
+            throw new Error(`LUTRE_LAYER_STATE_RESERVED: Layer ${layerName} cannot contribute reserved State namespace ${namespace}.`);
+        }
+        if (!Object.hasOwn(nextState, namespace)) {
+            nextState[namespace] = payload;
+            continue;
+        }
+        const current = nextState[namespace];
+        if (!isPlainObject(current) || !isPlainObject(payload)) {
+            throw new Error(`LUTRE_LAYER_STATE_OVERWRITE: Layer ${layerName} cannot overwrite existing State namespace ${namespace}.`);
+        }
+        for (const key of Object.keys(payload)) {
+            if (Object.hasOwn(current, key)) {
+                throw new Error(`LUTRE_LAYER_STATE_OVERWRITE: Layer ${layerName} cannot overwrite existing State property ${namespace}.${key}.`);
+            }
+        }
+        nextState[namespace] = { ...current, ...payload };
+    }
+    return nextState;
+}
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/dist/core/index.d.ts

@@ -1,15 +1,31 @@
-export * from './args.js';
-export * from './contract.js';
-export * from './context-key.js';
-export * from './env.js';
-export * from './error.js';
-export * from './execution.js';
-export * from './implementation.js';
-export * from './injection.js';
-export * from './layer.js';
-export * from './lifecycle.js';
-export * from './module.js';
-export * from './provider.js';
-export * from './runtime-input.js';
-export * from './schema.js';
-export * from './token.js';
+export { defineArgs, isArgsClass, loadArgs } from './args.js';
+export type { ArgsClass, ArgsKey, ArgsSchema } from './args.js';
+export { diagnostic, hasErrorDiagnostics, isErrorDiagnostic, } from './diagnostic.js';
+export type { Diagnostic } from './diagnostic.js';
+export { defineEnv, isEnvClass, loadEnv } from './env.js';
+export type { EnvClass, EnvKey, EnvSchema } from './env.js';
+export { defineError, DomainError } from './error.js';
+export type { ErrorDefinition } from './error.js';
+export { bindRuntimeCapability, defineExecution, defineExecutionExtension, executionDefinitionBrand, isExecutionDefinition, runtimeCapability, RuntimeCapabilityRegistry, } from './extension.js';
+export type { AnyExecutionExtension, ExecutionCompileContext, ExecutionContribution, ExecutionDefinition, ExecutionExtension, ExecutionExtensionDrainContext, ExecutionExtensionRuntime, ExecutionExtensionRuntimeContext, ExecutionExtensionValidationContext, ExecutionKernelRuntime, ExecutionLease, ExecutionProjectionContext, ExtensionOfDefinition, HostApiOfExtension, HostExtension, HostExtensionContext, RuntimeCapability, RuntimeCapabilityBinding, RuntimeCapabilityBindings, RuntimeCapabilityValue, } from './extension.js';
+export { composeLayers, defineLayer } from './generic-layer.js';
+export type { GenericLayer, GenericLayerContext, GenericLayerNext, } from './generic-layer.js';
+export { collectInjectedDependencies, inject, InjectionContextError, runInInjectionContext, } from './injection.js';
+export type { DependencyConsumer, DependencyConsumerDescriptor, InjectionContext, } from './injection.js';
+export { hook } from './lifecycle.js';
+export type { BeforeApplicationShutdown, LifecycleHook, ModuleLifecycle, OnApplicationBootstrap, OnApplicationShutdown, OnModuleDestroy, OnModuleInit, } from './lifecycle.js';
+export { ApplicationModelError, assertValidApplicationModel, buildApplicationModel, } from './model.js';
+export type { ApplicationModel, ApplicationModelBuildOptions, ApplicationModelEdge, ApplicationModelExtension, ApplicationModelExtensions, ApplicationModelNode, CompiledOf, ExecutionModelNode, FrameworkModelNode, LifecycleModelNode, ModuleModelNode, ProviderModelNode, } from './model.js';
+export { asModuleInstance, defineModule, moduleTypeInfo } from './module.js';
+export type { AnyModuleTemplate, ExtensionsOfModuleDefinition, ModuleDefinition, ModuleExtensions, ModuleHostApis, ModuleInstance, ModuleTemplate, ModuleTypeInfo, } from './module.js';
+export { argumentsProvider, environmentProvider, normalizeProvider, provide, } from './provider.js';
+export type { ArgumentsProvider, ClassProvider, ConditionalProvider, EnvironmentProvider, FactoryDefinition, FactoryProvider, ProviderDeclaration, ProviderDescriptor, ProviderScopeOptions, Scope, ValueProvider, } from './provider.js';
+export type { RuntimeInputContract, RuntimeInputKey } from './runtime-input.js';
+export { getSourceLocation, inheritSourceLocation, registerSourceLocation, } from './source-location.js';
+export type { SourceLocation } from './source-location.js';
+export { SchemaValidationError, supportsJsonSchema, validateSchema, } from './schema.js';
+export type { JsonSchemaInput, JsonSchemaOutput, SchemaInput, SchemaOutput, StandardJSONSchemaV1, StandardSchemaResult, StandardSchemaV1, } from './schema.js';
+export { token, tokenName } from './token.js';
+export type { AbstractClass, Class, Token, TokenLike, TokenOptions, TokenValue, } from './token.js';
+export { type } from './type.js';
+export type { Type, TypeOf } from './type.js';

package/dist/core/index.js

@@ -1,15 +1,15 @@
-export * from './args.js';
-export * from './contract.js';
-export * from './context-key.js';
-export * from './env.js';
-export * from './error.js';
-export * from './execution.js';
-export * from './implementation.js';
-export * from './injection.js';
-export * from './layer.js';
-export * from './lifecycle.js';
-export * from './module.js';
-export * from './provider.js';
-export * from './runtime-input.js';
-export * from './schema.js';
-export * from './token.js';
+export { defineArgs, isArgsClass, loadArgs } from './args.js';
+export { diagnostic, hasErrorDiagnostics, isErrorDiagnostic, } from './diagnostic.js';
+export { defineEnv, isEnvClass, loadEnv } from './env.js';
+export { defineError, DomainError } from './error.js';
+export { bindRuntimeCapability, defineExecution, defineExecutionExtension, executionDefinitionBrand, isExecutionDefinition, runtimeCapability, RuntimeCapabilityRegistry, } from './extension.js';
+export { composeLayers, defineLayer } from './generic-layer.js';
+export { collectInjectedDependencies, inject, InjectionContextError, runInInjectionContext, } from './injection.js';
+export { hook } from './lifecycle.js';
+export { ApplicationModelError, assertValidApplicationModel, buildApplicationModel, } from './model.js';
+export { asModuleInstance, defineModule, moduleTypeInfo } from './module.js';
+export { argumentsProvider, environmentProvider, normalizeProvider, provide, } from './provider.js';
+export { getSourceLocation, inheritSourceLocation, registerSourceLocation, } from './source-location.js';
+export { SchemaValidationError, supportsJsonSchema, validateSchema, } from './schema.js';
+export { token, tokenName } from './token.js';
+export { type } from './type.js';

package/dist/core/injection.d.ts

@@ -1,20 +1,10 @@
 import type { TokenLike, TokenValue } from './token.js';
-export interface LayerConsumer {
-    readonly kind: 'layer-consumer';
+export interface DependencyConsumerDescriptor {
     readonly id: string;
     readonly name: string;
+    readonly kind?: string;
 }
-export interface ImplementationConsumer {
-    readonly kind: 'implementation-consumer';
-    readonly id: string;
-    readonly name: string;
-}
-export interface TaskConsumer {
-    readonly kind: 'task-consumer';
-    readonly id: string;
-    readonly name: string;
-}
-export type DependencyConsumer = TokenLike | LayerConsumer | ImplementationConsumer | TaskConsumer;
+export type DependencyConsumer = TokenLike | DependencyConsumerDescriptor;
 export interface InjectionContext {
     readonly consumer: DependencyConsumer;
     readonly resolve: <T>(token: TokenLike<T>) => T;
@@ -26,3 +16,4 @@ export declare class InjectionContextError extends Error {
     constructor(token: TokenLike);
 }
 export declare function inject<TToken extends TokenLike>(token: TToken): TokenValue<TToken>;
+export declare function collectInjectedDependencies(consumer: DependencyConsumer, construct: () => unknown): readonly TokenLike[];

package/dist/core/injection.js

@@ -33,3 +33,66 @@ export function inject(token) {
     context.record?.(context.consumer, token);
     return context.resolve(token);
 }
+function dependencyProbeTarget() { }
+class DependencyProbeBoundary extends Error {
+    source;
+    constructor(source) {
+        super(`Dependency probe reached runtime-dependent value: ${source}`);
+        this.source = source;
+        this.name = 'DependencyProbeBoundary';
+    }
+}
+export function collectInjectedDependencies(consumer, construct) {
+    const dependencies = new Set();
+    try {
+        runInInjectionContext({
+            consumer,
+            resolve: (token) => createDependencyProbeValue(token),
+            record: (_consumer, dependency) => dependencies.add(dependency),
+        }, construct);
+    }
+    catch (error) {
+        if (!(error instanceof DependencyProbeBoundary))
+            throw error;
+    }
+    return [...dependencies];
+}
+function createDependencyProbeValue(token) {
+    const source = typeof token === 'function' ? token.name : token.id;
+    const boundary = (operation) => new DependencyProbeBoundary(`${source}.${String(operation)}`);
+    return new Proxy(dependencyProbeTarget, {
+        apply() {
+            throw boundary('[[Call]]');
+        },
+        construct() {
+            throw boundary('[[Construct]]');
+        },
+        get(_target, key) {
+            throw boundary(key);
+        },
+        set(_target, key) {
+            throw boundary(key);
+        },
+        has(_target, key) {
+            throw boundary(key);
+        },
+        ownKeys() {
+            throw boundary('*');
+        },
+        getOwnPropertyDescriptor(_target, key) {
+            throw boundary(key);
+        },
+        defineProperty(_target, key) {
+            throw boundary(key);
+        },
+        deleteProperty(_target, key) {
+            throw boundary(key);
+        },
+        getPrototypeOf() {
+            throw boundary('[[Prototype]]');
+        },
+        setPrototypeOf() {
+            throw boundary('[[Prototype]]');
+        },
+    });
+}

package/dist/core/model/context.d.ts

@@ -0,0 +1,18 @@
+import type { Diagnostic } from '../diagnostic.js';
+import type { ModuleInstance } from '../module.js';
+import type { ProviderDescriptor } from '../provider.js';
+import type { TokenLike } from '../token.js';
+import type { ApplicationModelBuildOptions, ApplicationModelEdge, ApplicationModelNode, ExecutionModelNode, ProviderModelNode } from './types.js';
+export interface ModelBuildContext {
+    readonly options: ApplicationModelBuildOptions;
+    readonly modules: readonly ModuleInstance[];
+    readonly moduleIds: ReadonlyMap<ModuleInstance, string>;
+    readonly nodes: ApplicationModelNode[];
+    readonly edges: ApplicationModelEdge[];
+    readonly diagnostics: Diagnostic[];
+    readonly providers: ProviderDescriptor[];
+    readonly executions: ExecutionModelNode[];
+    readonly providerNodes: Map<TokenLike, ProviderModelNode>;
+    nextProviderId(): string;
+}
+export declare function createModelBuildContext(options: ApplicationModelBuildOptions): ModelBuildContext;

package/dist/core/model/context.js

@@ -0,0 +1,34 @@
+import { asModuleInstance } from '../module.js';
+function collectModules(roots) {
+    const result = [];
+    const seen = new Set();
+    const visit = (candidate) => {
+        const module = asModuleInstance(candidate);
+        if (seen.has(module))
+            return;
+        seen.add(module);
+        for (const imported of module.definition.imports ?? [])
+            visit(imported);
+        result.push(module);
+    };
+    for (const root of roots)
+        visit(root);
+    return result;
+}
+export function createModelBuildContext(options) {
+    const modules = collectModules(options.modules);
+    const moduleIds = new Map(modules.map((module, index) => [module, `module:${index + 1}`]));
+    let providerOrdinal = 0;
+    return {
+        options,
+        modules,
+        moduleIds,
+        nodes: [],
+        edges: [],
+        diagnostics: [],
+        providers: [],
+        executions: [],
+        providerNodes: new Map(),
+        nextProviderId: () => `provider:${++providerOrdinal}`,
+    };
+}

package/dist/core/model/lifecycle.d.ts

@@ -0,0 +1,5 @@
+import type { ModuleInstance } from '../module.js';
+import type { ApplicationModelEdge, ApplicationModelNode } from './types.js';
+import type { ModelBuildContext } from './context.js';
+export declare function appendLifecycleNodes(module: ModuleInstance, moduleId: string, nodes: ApplicationModelNode[], edges: ApplicationModelEdge[]): void;
+export declare function resolveLifecycleDependencies(context: ModelBuildContext): void;

package/dist/core/model/lifecycle.js

@@ -0,0 +1,44 @@
+import { diagnostic } from '../diagnostic.js';
+import { isFrameworkProvidedToken } from '../token-internal.js';
+import { tokenName } from '../token.js';
+import { snapshotLifecycleHook } from './snapshot.js';
+import { isTokenVisible, moduleDeclaresToken } from './visibility.js';
+export function appendLifecycleNodes(module, moduleId, nodes, edges) {
+    const lifecycle = module.definition.lifecycle;
+    if (!lifecycle)
+        return;
+    for (const [phase, hook] of Object.entries(lifecycle)) {
+        const id = `lifecycle:${moduleId}:${phase}`;
+        nodes.push({
+            kind: 'lifecycle',
+            id,
+            moduleId,
+            phase,
+            hook: snapshotLifecycleHook(hook),
+        });
+        edges.push({ from: moduleId, to: id, kind: 'owns' });
+    }
+}
+export function resolveLifecycleDependencies(context) {
+    const { nodes, providerNodes, modules, moduleIds, edges, diagnostics } = context;
+    for (const lifecycle of nodes.filter((node) => node.kind === 'lifecycle')) {
+        for (const dependency of lifecycle.hook.inject) {
+            const provider = providerNodes.get(dependency);
+            if (provider) {
+                edges.push({ from: lifecycle.id, to: provider.id, kind: 'injects' });
+                const sourceModule = modules.find((candidate) => moduleIds.get(candidate) === lifecycle.moduleId);
+                const providerModule = modules.find((candidate) => moduleIds.get(candidate) === provider.moduleId);
+                if (sourceModule &&
+                    providerModule &&
+                    provider.moduleId !== lifecycle.moduleId &&
+                    !moduleDeclaresToken(sourceModule, dependency) &&
+                    !isTokenVisible(sourceModule, providerModule, dependency)) {
+                    diagnostics.push(diagnostic('LUTRE_MODULE_VISIBILITY', `Lifecycle ${lifecycle.phase} depends on private ${tokenName(dependency)} from another Module.`, lifecycle.id));
+                }
+            }
+            else if (!isFrameworkProvidedToken(dependency)) {
+                diagnostics.push(diagnostic('LUTRE_LIFECYCLE_DEPENDENCY_MISSING', `Lifecycle ${lifecycle.phase} requires ${tokenName(dependency)}, but no provider is declared.`, lifecycle.id));
+            }
+        }
+    }
+}

package/dist/core/model/modules.d.ts

@@ -0,0 +1,2 @@
+import type { ModelBuildContext } from './context.js';
+export declare function collectModuleDeclarations(context: ModelBuildContext): void;