@loutrejs/loutre 0.2.0 → 0.4.0

package/dist/http/client.d.ts

@@ -0,0 +1,72 @@
+import { type ContractDefinition, type ProcedureDefinition, type SchemaInput, type SchemaOutput, type StandardSchemaV1 } from '../core/index.js';
+import type { HttpHeaders, HttpParamsSchemas, HttpProtocol, HttpProtocolDefinition, HttpRequestBodyDefinition, HttpResponseDefinition } from './definitions.js';
+import { type PathParamNames, type RawPathParams } from './path.js';
+export interface HttpClientTransportRequest {
+    readonly method: string;
+    readonly path: string;
+    readonly query?: unknown;
+    readonly headers?: unknown;
+    readonly body?: unknown;
+    readonly contentType?: string;
+}
+export interface HttpClientTransportResponse {
+    readonly status: number;
+    readonly body: unknown;
+    readonly headers?: HttpHeaders;
+}
+export type HttpClientTransport = (request: HttpClientTransportRequest) => Promise<HttpClientTransportResponse>;
+type HttpProtocolOf<TProcedure extends ProcedureDefinition> = TProcedure['protocols'] extends {
+    readonly http: infer TProtocol;
+} ? TProtocol extends HttpProtocol<infer TDefinition> ? HttpProtocol<TDefinition> : never : never;
+type HttpProcedureNames<TContract extends ContractDefinition> = {
+    [TProcedure in keyof TContract['procedures'] & string]: HttpProtocolOf<TContract['procedures'][TProcedure]> extends never ? never : TProcedure;
+}[keyof TContract['procedures'] & string];
+type HttpDefinitionOf<TContract extends ContractDefinition, TProcedure extends HttpProcedureNames<TContract>> = HttpProtocolOf<TContract['procedures'][TProcedure]>['definition'];
+type RequestBodySchema<TBody> = TBody extends HttpRequestBodyDefinition<infer TSchema> ? TSchema : never;
+type PathParamsInput<TDefinition extends HttpProtocolDefinition> = PathParamNames<TDefinition['path']> extends never ? never : TDefinition['request'] extends {
+    readonly params: infer TSchemas extends HttpParamsSchemas;
+} ? Readonly<{
+    [TName in keyof TSchemas]: SchemaInput<TSchemas[TName]>;
+}> : RawPathParams<TDefinition['path']>;
+type RequestPartInput<TDefinition extends HttpProtocolDefinition, TPart extends 'query' | 'headers'> = TDefinition['request'] extends infer TRequest ? TRequest extends Record<TPart, infer TSchema extends StandardSchemaV1> ? SchemaInput<TSchema> : never : never;
+type RequestBodyInput<TDefinition extends HttpProtocolDefinition> = TDefinition['request'] extends {
+    readonly body: infer TBody extends HttpRequestBodyDefinition;
+} ? SchemaInput<RequestBodySchema<TBody>> : never;
+type RequestField<TName extends string, TValue> = [TValue] extends [never] ? object : undefined extends TValue ? {
+    readonly [TKey in TName]?: Exclude<TValue, undefined>;
+} : {
+    readonly [TKey in TName]: TValue;
+};
+export type HttpClientRequest<TDefinition extends HttpProtocolDefinition> = RequestField<'params', PathParamsInput<TDefinition>> & RequestField<'query', RequestPartInput<TDefinition, 'query'>> & RequestField<'headers', RequestPartInput<TDefinition, 'headers'>> & RequestField<'body', RequestBodyInput<TDefinition>>;
+type ResponseBodyOutput<TResponse extends HttpResponseDefinition> = TResponse extends {
+    readonly stream: 'server';
+} ? AsyncIterable<SchemaOutput<TResponse['body']>> : SchemaOutput<TResponse['body']>;
+type ResponseHeadersOutput<TResponse extends HttpResponseDefinition> = TResponse extends {
+    readonly headers: infer THeaders extends StandardSchemaV1;
+} ? SchemaOutput<THeaders> : HttpHeaders;
+export type HttpClientResponse<TDefinition extends HttpProtocolDefinition> = {
+    [TVariant in keyof TDefinition['responses'] & string]: NonNullable<TDefinition['responses'][TVariant]> extends infer TResponse extends HttpResponseDefinition ? {
+        readonly status: TResponse['status'];
+        readonly body: ResponseBodyOutput<TResponse>;
+        readonly headers: ResponseHeadersOutput<TResponse>;
+    } : never;
+}[keyof TDefinition['responses'] & string];
+type HttpClientMethod<TDefinition extends HttpProtocolDefinition> = keyof HttpClientRequest<TDefinition> extends never ? () => Promise<HttpClientResponse<TDefinition>> : (request: HttpClientRequest<TDefinition>) => Promise<HttpClientResponse<TDefinition>>;
+export type HttpClient<TContract extends ContractDefinition> = {
+    readonly [TProcedure in HttpProcedureNames<TContract>]: HttpClientMethod<HttpDefinitionOf<TContract, TProcedure>>;
+};
+export declare class HttpClientResponseError extends Error {
+    readonly status: number;
+    readonly method: string;
+    readonly path: string;
+    readonly procedure: string;
+    constructor(status: number, method: string, path: string, procedure: string, message: string, options?: ErrorOptions);
+}
+export declare function createHttpClient<const TContract extends ContractDefinition>(contract: TContract, transport: HttpClientTransport): HttpClient<TContract>;
+export interface FetchHttpTransportOptions {
+    readonly baseUrl: string | URL;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly headers?: HeadersInit;
+}
+export declare function fetchHttpTransport(options: FetchHttpTransportOptions): HttpClientTransport;
+export {};

package/dist/http/client.js

@@ -0,0 +1,258 @@
+import { SchemaValidationError, validateSchema, } from '../core/index.js';
+import { parseHttpPath, } from './path.js';
+export class HttpClientResponseError extends Error {
+    status;
+    method;
+    path;
+    procedure;
+    constructor(status, method, path, procedure, message, options) {
+        super(message, options);
+        this.status = status;
+        this.method = method;
+        this.path = path;
+        this.procedure = procedure;
+        this.name = 'HttpClientResponseError';
+    }
+}
+export function createHttpClient(contract, transport) {
+    const client = {};
+    for (const [procedureName, procedure] of Object.entries(contract.procedures)) {
+        const definition = httpDefinitionOf(procedure);
+        if (!definition)
+            continue;
+        client[procedureName] = async (request = {}) => {
+            const response = await transport({
+                method: definition.method,
+                path: interpolatePath(definition.path, request.params),
+                ...(request.query === undefined ? {} : { query: request.query }),
+                ...(request.headers === undefined ? {} : { headers: request.headers }),
+                ...(request.body === undefined ? {} : { body: request.body }),
+                ...(definition.request?.body === undefined
+                    ? {}
+                    : { contentType: definition.request.body.contentType }),
+            });
+            return decodeResponse(procedureName, definition, response);
+        };
+    }
+    return Object.freeze(client);
+}
+function httpDefinitionOf(procedure) {
+    const protocol = procedure.protocols.http;
+    if (!protocol ||
+        protocol.protocol !== 'http' ||
+        !('definition' in protocol)) {
+        return undefined;
+    }
+    return protocol.definition;
+}
+function interpolatePath(path, params) {
+    const segments = parseHttpPath(path);
+    if (segments.length === 0)
+        return '/';
+    return `/${segments
+        .map((segment) => {
+        if (segment.kind === 'static')
+            return segment.value;
+        const value = params?.[segment.name];
+        if (value === undefined) {
+            throw new Error(`Missing HTTP path parameter: ${segment.name}`);
+        }
+        return encodeURIComponent(String(value));
+    })
+        .join('/')}`;
+}
+async function decodeResponse(procedure, definition, response) {
+    const target = describeHttpTarget(definition, procedure);
+    const candidates = Object.values(definition.responses).filter((candidate) => candidate.status === response.status);
+    if (candidates.length === 0) {
+        throw new HttpClientResponseError(response.status, definition.method, definition.path, procedure, `${target} returned undeclared HTTP status ${response.status}`);
+    }
+    let lastValidationError;
+    for (const candidate of candidates) {
+        try {
+            const body = candidate.stream
+                ? validatedResponseStream(candidate.body, response.body, procedure, definition, response.status)
+                : await validateSchema(candidate.body, response.body);
+            const headers = candidate.headers
+                ? await validateSchema(candidate.headers, response.headers ?? {})
+                : (response.headers ?? {});
+            return Object.freeze({ status: response.status, body, headers });
+        }
+        catch (error) {
+            if (!(error instanceof SchemaValidationError))
+                throw error;
+            lastValidationError = error;
+        }
+    }
+    throw new HttpClientResponseError(response.status, definition.method, definition.path, procedure, `${target} returned a response that does not match its Contract`, lastValidationError ? { cause: lastValidationError } : undefined);
+}
+function validatedResponseStream(schema, value, procedure, definition, status) {
+    const target = describeHttpTarget(definition, procedure);
+    if (!isAsyncIterable(value)) {
+        throw new HttpClientResponseError(status, definition.method, definition.path, procedure, `${target} returned a non-stream body for a server-stream response`);
+    }
+    return {
+        async *[Symbol.asyncIterator]() {
+            try {
+                for await (const item of value)
+                    yield await validateSchema(schema, item);
+            }
+            catch (error) {
+                throw new HttpClientResponseError(status, definition.method, definition.path, procedure, `${target} returned an invalid server-stream item`, { cause: error });
+            }
+        },
+    };
+}
+function describeHttpTarget(definition, procedure) {
+    return `${definition.method.toUpperCase()} ${definition.path} (${procedure})`;
+}
+function isAsyncIterable(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        Symbol.asyncIterator in value &&
+        typeof value[Symbol.asyncIterator] === 'function');
+}
+export function fetchHttpTransport(options) {
+    const fetchImplementation = options.fetch ?? globalThis.fetch;
+    return async (request) => {
+        const url = new URL(request.path, options.baseUrl);
+        appendQuery(url.searchParams, request.query);
+        const headers = new Headers(options.headers);
+        appendHeaders(headers, request.headers);
+        if (request.contentType && !headers.has('content-type')) {
+            headers.set('content-type', request.contentType);
+        }
+        const response = await fetchImplementation(url, {
+            method: request.method,
+            headers,
+            ...(request.body === undefined
+                ? {}
+                : { body: encodeBody(request.body, request.contentType) }),
+        });
+        return {
+            status: response.status,
+            body: await decodeFetchBody(response),
+            headers: Object.fromEntries(response.headers.entries()),
+        };
+    };
+}
+function appendQuery(searchParams, query) {
+    if (query === undefined || query === null)
+        return;
+    if (query instanceof URLSearchParams) {
+        for (const [key, value] of query)
+            searchParams.append(key, value);
+        return;
+    }
+    if (typeof query !== 'object') {
+        throw new TypeError('HTTP client query must be an object or URLSearchParams');
+    }
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                searchParams.append(key, String(item));
+        }
+        else {
+            searchParams.append(key, String(value));
+        }
+    }
+}
+function appendHeaders(headers, value) {
+    if (value === undefined || value === null)
+        return;
+    if (value instanceof Headers) {
+        for (const [name, header] of value)
+            headers.set(name, header);
+        return;
+    }
+    if (typeof value !== 'object') {
+        throw new TypeError('HTTP client headers must be an object or Headers');
+    }
+    for (const [name, header] of Object.entries(value)) {
+        if (header === undefined)
+            continue;
+        if (Array.isArray(header)) {
+            headers.set(name, header.map(String).join(', '));
+        }
+        else {
+            headers.set(name, String(header));
+        }
+    }
+}
+function encodeBody(body, contentType) {
+    const mediaType = normalizeMediaType(contentType);
+    if (mediaType === 'application/json' || mediaType?.endsWith('+json')) {
+        return JSON.stringify(body);
+    }
+    return body;
+}
+async function decodeFetchBody(response) {
+    if (response.status === 204 || response.status === 205)
+        return undefined;
+    const mediaType = normalizeMediaType(response.headers.get('content-type'));
+    if (mediaType === 'text/event-stream') {
+        if (!response.body) {
+            throw new Error('Server-stream HTTP response has no body');
+        }
+        return decodeServerSentEvents(response.body);
+    }
+    if (mediaType === 'application/json' || mediaType?.endsWith('+json')) {
+        return response.json();
+    }
+    return response.text();
+}
+function normalizeMediaType(value) {
+    const mediaType = value?.split(';', 1)[0]?.trim().toLowerCase();
+    return mediaType || undefined;
+}
+async function* decodeServerSentEvents(stream) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let completed = false;
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done) {
+                completed = true;
+                buffer += decoder.decode();
+                break;
+            }
+            buffer += decoder.decode(next.value, { stream: true });
+            buffer = normalizeEventStreamNewlines(buffer);
+            let boundary = buffer.indexOf('\n\n');
+            while (boundary >= 0) {
+                const event = buffer.slice(0, boundary);
+                buffer = buffer.slice(boundary + 2);
+                const data = event
+                    .split('\n')
+                    .filter((line) => line.startsWith('data:'))
+                    .map((line) => line.slice('data:'.length).trimStart())
+                    .join('\n');
+                if (data.length > 0)
+                    yield JSON.parse(data);
+                boundary = buffer.indexOf('\n\n');
+            }
+        }
+        buffer = normalizeEventStreamNewlines(buffer).trim();
+        if (buffer.length > 0) {
+            const data = buffer
+                .split('\n')
+                .filter((line) => line.startsWith('data:'))
+                .map((line) => line.slice('data:'.length).trimStart())
+                .join('\n');
+            if (data.length > 0)
+                yield JSON.parse(data);
+        }
+    }
+    finally {
+        if (!completed)
+            await reader.cancel();
+        reader.releaseLock();
+    }
+}
+function normalizeEventStreamNewlines(value) {
+    return value.replaceAll('\r\n', '\n').replaceAll('\r', '\n');
+}

package/dist/http/definitions.d.ts

@@ -1,4 +1,4 @@
-import type { ContractDefinition, ContextProvidedBeforeTerminal, HasValidationBeforeTerminal, IsValidProtocolPipeline, PipelineItem, ProtocolDescriptor, SchemaInput, SchemaOutput, ShortCircuitDeclarationsOf, ShortCircuitResultOf, StandardSchemaV1, TerminalLayerDescriptor, ValidationLayerDescriptor } from '../core/index.js';
+import type { ContractDefinition, ContextProvidedBeforeTerminal, HasValidationBeforeTerminal, IsValidProtocolPipeline, PipelineItem, ProtocolDescriptor, ProtocolFactory, ProtocolGroup, SchemaInput, SchemaOutput, ShortCircuitDeclarationsOf, ShortCircuitResultOf, StandardSchemaV1, TerminalLayerDescriptor, ValidationLayerDescriptor } from '../core/index.js';
 import type { Logger } from '../runtime/index.js';
 import { type HttpDispatchKey, type IsValidHttpPath, type PathParamNames, type RawPathParams } from './path.js';
 export type HttpParamsSchemas = Readonly<Record<string, StandardSchemaV1>>;
@@ -133,11 +133,19 @@ type AreErrorMappingsCompatible<TResponses extends HttpProtocolDefinition['respo
     [TVariant in keyof TResponses]: IsErrorMappingCompatible<TResponses[TVariant]>;
 }[keyof TResponses] ? false : true;
 declare function defineHttp<const TDefinition extends HttpProtocolDefinition>(definition: TDefinition & HttpPipelineConstraint<TDefinition> & HttpResponseConstraint<TDefinition> & HttpPathConstraint<TDefinition>): HttpProtocol<TDefinition>;
-export declare const http: typeof defineHttp & {
-    protocol: 'http';
-    controller: TerminalLayerDescriptor<"http">;
-    error: typeof httpError;
+type HttpProtocolGroup<TDefinitions extends Record<string, HttpProtocolDefinition>> = ProtocolGroup<'http', {
+    [K in keyof TDefinitions]: HttpProtocol<TDefinitions[K]>;
+}>;
+type HttpDefinitionsConstraint<TDefinitions extends Record<string, HttpProtocolDefinition>> = {
+    [K in keyof TDefinitions]: TDefinitions[K] & HttpPipelineConstraint<TDefinitions[K]> & HttpResponseConstraint<TDefinitions[K]> & HttpPathConstraint<TDefinitions[K]>;
 };
+export interface HttpProtocolFactory extends ProtocolFactory<'http'> {
+    <const TDefinitions extends Record<string, HttpProtocolDefinition>>(definitions: TDefinitions & HttpDefinitionsConstraint<TDefinitions>): HttpProtocolGroup<TDefinitions>;
+    readonly route: typeof defineHttp;
+    readonly controller: TerminalLayerDescriptor<'http'>;
+    readonly error: typeof httpError;
+}
+export declare const http: HttpProtocolFactory;
 export declare const validate: Readonly<{
     params: ValidationLayerDescriptor & {
         readonly part: "params";

package/dist/http/definitions.js

@@ -1,4 +1,4 @@
-import { childPipelineOf } from '../core/index.js';
+import { childPipelineOf, protocolGroup } from '../core/index.js';
 import { createHttpDispatchKey, parseHttpPath, } from './path.js';
 const controller = Object.freeze({
     kind: 'terminal',
@@ -37,8 +37,12 @@ function hasParamsValidation(pipeline) {
         (item.kind === 'layer' &&
             hasParamsValidation(childPipelineOf(item) ?? [])));
 }
-export const http = Object.assign(defineHttp, {
+function defineHttpGroup(definitions) {
+    return protocolGroup('http', Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [name, defineHttp(definition)])));
+}
+export const http = Object.assign(defineHttpGroup, {
     protocol: 'http',
+    route: defineHttp,
     controller,
     error: httpError,
 });

package/dist/http/index.d.ts

@@ -1,5 +1,6 @@
 export * from './application.js';
 export * from './basic-auth.js';
+export * from './client.js';
 export type { CorsLayerDescriptor, CorsOptions, CorsOrigin } from './cors.js';
 export * from './definitions.js';
 export { http } from './hosted-protocol.js';

package/dist/http/index.js

@@ -1,5 +1,6 @@
 export * from './application.js';
 export * from './basic-auth.js';
+export * from './client.js';
 export * from './definitions.js';
 export { http } from './hosted-protocol.js';
 export * from './request-body.js';

package/dist/message-port/index.d.ts

@@ -1,4 +1,4 @@
-import { type ContextProvidedBeforeTerminal, type IsValidProtocolPipeline, type ContractDefinition, type PipelineItem, type ProtocolDescriptor, type SchemaOutput, type StandardSchemaV1, type TerminalLayerDescriptor } from '../core/index.js';
+import { type ContextProvidedBeforeTerminal, type IsValidProtocolPipeline, type ContractDefinition, type PipelineItem, type ProtocolDescriptor, type ProtocolFactory, type ProtocolGroup, type SchemaOutput, type StandardSchemaV1, type TerminalLayerDescriptor } from '../core/index.js';
 import type { ApplicationGraphIR } from '../graph/index.js';
 import { ApplicationRuntime, Logger } from '../runtime/index.js';
 export interface MessagePortResponseDefinition {
@@ -17,10 +17,18 @@ declare function defineMessagePort<const TDefinition extends MessagePortProtocol
 type MessagePortPipelineConstraint<TDefinition extends MessagePortProtocolDefinition> = IsValidProtocolPipeline<TDefinition['pipeline'], 'messagePort'> extends true ? unknown : {
     readonly pipeline: never;
 };
-export declare const messagePort: typeof defineMessagePort & {
-    protocol: 'messagePort';
-    handler: TerminalLayerDescriptor<"messagePort">;
+type MessagePortProtocolGroup<TDefinitions extends Record<string, MessagePortProtocolDefinition>> = ProtocolGroup<'messagePort', {
+    [K in keyof TDefinitions]: MessagePortProtocol<TDefinitions[K]>;
+}>;
+type MessagePortDefinitionsConstraint<TDefinitions extends Record<string, MessagePortProtocolDefinition>> = {
+    [K in keyof TDefinitions]: TDefinitions[K] & MessagePortPipelineConstraint<TDefinitions[K]>;
 };
+export interface MessagePortProtocolFactory extends ProtocolFactory<'messagePort'> {
+    <const TDefinitions extends Record<string, MessagePortProtocolDefinition>>(definitions: TDefinitions & MessagePortDefinitionsConstraint<TDefinitions>): MessagePortProtocolGroup<TDefinitions>;
+    readonly route: typeof defineMessagePort;
+    readonly handler: TerminalLayerDescriptor<'messagePort'>;
+}
+export declare const messagePort: MessagePortProtocolFactory;
 export interface LogicalMessagePortResult<TVariant extends string = string, TValue = unknown> {
     readonly kind: 'message-port-result';
     readonly variant: TVariant;

package/dist/message-port/index.js

@@ -1,4 +1,4 @@
-import { validateSchema, } from '../core/index.js';
+import { validateSchema, protocolGroup, } from '../core/index.js';
 import { executePipeline, Logger, normalizeUnknownError, } from '../runtime/index.js';
 const handler = Object.freeze({
     kind: 'terminal',
@@ -15,8 +15,15 @@ function defineMessagePort(definition) {
         definition,
     };
 }
-export const messagePort = Object.assign(defineMessagePort, {
+function defineMessagePortGroup(definitions) {
+    return protocolGroup('messagePort', Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [
+        name,
+        defineMessagePort(definition),
+    ])));
+}
+export const messagePort = Object.assign(defineMessagePortGroup, {
     protocol: 'messagePort',
+    route: defineMessagePort,
     handler,
 });
 export function createMessagePortExecution(options) {

package/dist/runtime/application.d.ts

@@ -1,4 +1,4 @@
-import { type ArgsClass, type EnvClass, type ModuleInstance, type ModuleTemplate, type TaskArguments, type TaskDescriptor, type TaskOutput } from '../core/index.js';
+import { type ArgsClass, type EnvClass, type ModuleInstance, type ModuleTemplate, type TaskArguments, type TaskDescriptor, type TaskOutput, type TokenLike } from '../core/index.js';
 import { Container, type RuntimeModuleGraph } from './di.js';
 import { Logger } from './logger.js';
 export interface ApplicationRuntimeOptions {
@@ -27,6 +27,7 @@ export declare class ApplicationRuntime {
     readonly container: Container;
     constructor(roots: readonly (ModuleInstance | ModuleTemplate<void>)[], options?: ApplicationRuntimeOptions);
     initialize(): Promise<void>;
+    get<T>(token: TokenLike<T>): T;
     run<TTask extends TaskDescriptor<any, any>>(task: TTask, ...args: TaskArguments<TTask>): Promise<TaskOutput<TTask>>;
     /** public run()ではTrigger専用Taskを拒否するため、Trigger Host専用経路を分ける。 */
     runTask<TTask extends TaskDescriptor<any, any>>(task: TTask, ...args: TaskArguments<TTask>): Promise<TaskOutput<TTask>>;

package/dist/runtime/application.js

@@ -164,6 +164,18 @@ export class ApplicationRuntime {
         }
         this.#prepared = true;
     }
+    get(token) {
+        if (this.#state === 'created' || this.#state === 'initializing') {
+            throw applicationStateError('LUTRE_APP_NOT_INITIALIZED');
+        }
+        if (this.#state === 'stopping') {
+            throw applicationStateError('LUTRE_APP_STOPPING');
+        }
+        if (this.#state === 'stopped') {
+            throw applicationStateError('LUTRE_APP_STOPPED');
+        }
+        return this.container.get(token);
+    }
     run(task, ...args) {
         if (!this.#publicTasks.has(task)) {
             return Promise.reject(new Error(`LUTRE_TASK_002: Task ${task.name} is not registered in Application.tasks.`));
@@ -283,9 +295,12 @@ export class ApplicationRuntime {
     }
 }
 function applicationStateError(code) {
-    return new Error(code === 'LUTRE_APP_STOPPING'
-        ? `${code}: Application is stopping and cannot accept new executions.`
-        : `${code}: Application is stopped and cannot accept new executions.`);
+    const message = code === 'LUTRE_APP_NOT_INITIALIZED'
+        ? 'Application is not initialized.'
+        : code === 'LUTRE_APP_STOPPING'
+            ? 'Application is stopping and cannot accept new executions.'
+            : 'Application is stopped and cannot accept new executions.';
+    return new Error(`${code}: ${message}`);
 }
 function collectApplicationPipelines(modules) {
     const pipelines = [];

package/dist/runtime/di.d.ts

@@ -24,6 +24,7 @@ export declare class Container {
     bindEnvironment(environment: EnvClass, value: object): void;
     bindArguments(argumentsContract: ArgsClass, value: object): void;
     resolve<T>(token: TokenLike<T>): T;
+    get<T>(token: TokenLike<T>): T;
     probeClass<T>(target: Class<T>): T;
     prepareImplementation(implementation: ImplementationDescriptor): void;
     implementationRuntime(implementation: ImplementationDescriptor): object;

package/dist/runtime/di.js

@@ -110,6 +110,37 @@ export class Container {
     resolve(token) {
         return this.#resolve(token);
     }
+    get(token) {
+        const provider = this.#providers.get(token);
+        if (!provider) {
+            if (isEnvClass(token)) {
+                throw new DependencyResolutionError(`LUTRE_ENV_002: ${token.name} is not declared by any Module.environment.`);
+            }
+            if (isArgsClass(token)) {
+                throw new DependencyResolutionError(`LUTRE_ARGS_002: ${token.name} is not declared by Application.arguments.`);
+            }
+            throw new DependencyResolutionError(`LUTRE_DI_UNRESOLVED: Application requires ${tokenName(token)}, but no provider is declared for ${tokenName(token)}.`);
+        }
+        if (provider.scope !== 'application') {
+            throw new DependencyResolutionError(`LUTRE_DI_SCOPED_GET: ${tokenName(token)} is ${provider.scope}-scoped and cannot be retrieved with Application.get().`);
+        }
+        if (provider.kind === 'environment') {
+            if (this.#environment.has(provider.provide)) {
+                return this.#environment.get(provider.provide);
+            }
+            throw new DependencyResolutionError(`LUTRE_ENV_005: Environment ${provider.provide.name} requires a runtime Environment source before Application initialization.`);
+        }
+        if (provider.kind === 'arguments') {
+            if (this.#arguments.has(provider.provide)) {
+                return this.#arguments.get(provider.provide);
+            }
+            throw new DependencyResolutionError(`LUTRE_ARGS_005: Arguments ${provider.provide.name} requires runtime Arguments before Application initialization.`);
+        }
+        if (this.#applicationCache.has(token)) {
+            return this.#applicationCache.get(token);
+        }
+        throw new DependencyResolutionError(`LUTRE_DI_NOT_INITIALIZED: ${tokenName(token)} has not been constructed by Application initialization.`);
+    }
     probeClass(target) {
         try {
             return this.#instantiate(target, [target]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loutrejs/loutre",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "license": "MIT",
   "type": "module",
   "files": [