@loutrejs/loutre 0.1.0

package/dist/adapters/aws-lambda.d.ts

@@ -0,0 +1,52 @@
+import { type ApplicationDefinition, type BootstrapArguments, type HasHttp } from '../application/index.js';
+type IsAny<TValue> = 0 extends 1 & TValue ? true : false;
+type HttpApplication<TDefinition extends ApplicationDefinition> = IsAny<TDefinition> extends true ? TDefinition : HasHttp<TDefinition> extends true ? TDefinition : never;
+export type AwsLambdaBindBaseOptions<TDefinition extends ApplicationDefinition> = {
+    readonly application: HttpApplication<TDefinition>;
+    readonly environment?: unknown;
+} & BootstrapArguments<TDefinition>;
+export type AwsLambdaBindOptions<TDefinition extends ApplicationDefinition> = AwsLambdaBindBaseOptions<TDefinition> & {
+    readonly response?: 'buffered';
+};
+export type AwsLambdaStreamingBindOptions<TDefinition extends ApplicationDefinition> = AwsLambdaBindBaseOptions<TDefinition> & {
+    readonly response: 'streaming';
+};
+export interface AwsLambdaHttpEvent {
+    readonly rawPath?: string;
+    readonly rawQueryString?: string;
+    readonly requestContext?: {
+        readonly http?: {
+            readonly method?: string;
+        };
+    };
+    readonly headers?: Readonly<Record<string, string | undefined>>;
+    readonly body?: string | null;
+    readonly isBase64Encoded?: boolean;
+}
+export interface AwsLambdaHttpResult {
+    readonly statusCode: number;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly cookies?: readonly string[];
+    readonly body: string;
+    readonly isBase64Encoded: boolean;
+}
+export type AwsLambdaHttpHandler = (event: AwsLambdaHttpEvent) => Promise<AwsLambdaHttpResult>;
+export interface AwsLambdaResponseStream {
+    write(chunk: Uint8Array): boolean;
+    end(): void;
+    once?(event: 'drain', listener: () => void): unknown;
+    setMetadata?(metadata: {
+        readonly statusCode: number;
+        readonly headers: Readonly<Record<string, string>>;
+        readonly cookies?: readonly string[];
+    }): void;
+}
+export type AwsLambdaStreamingHttpHandler = (event: AwsLambdaHttpEvent, output: AwsLambdaResponseStream, context?: unknown) => Promise<void>;
+export declare const awsLambdaRuntime: {
+    readonly runtime: 'aws-lambda';
+    readonly capabilities: Set<string>;
+    readonly bind: typeof bind;
+};
+declare function bind<const TDefinition extends ApplicationDefinition>(options: AwsLambdaStreamingBindOptions<TDefinition>): AwsLambdaStreamingHttpHandler;
+declare function bind<const TDefinition extends ApplicationDefinition>(options: AwsLambdaBindOptions<TDefinition>): AwsLambdaHttpHandler;
+export {};

package/dist/adapters/aws-lambda.js

@@ -0,0 +1,114 @@
+import { binding, } from '../application/index.js';
+export const awsLambdaRuntime = {
+    runtime: 'aws-lambda',
+    capabilities: new Set([
+        'http.server',
+        'http.response.streaming',
+        'stream.readable',
+        'stream.writable',
+        'env.runtime',
+        'crypto.random',
+    ]),
+    bind,
+};
+function bind(options) {
+    const invocation = binding.invocation({
+        application: options.application,
+        environment: 'environment' in options ? options.environment : process.env,
+        ...('arguments' in options ? { arguments: options.arguments } : {}),
+    });
+    const http = 'http' in invocation
+        ? invocation.http
+        : undefined;
+    if (!http) {
+        void invocation.application.close();
+        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: awsLambdaRuntime.bind() requires an HTTP-capable Application.');
+    }
+    if (options.response === 'streaming') {
+        const handler = createAwsLambdaStreamingHttpDriver(http);
+        const aws = awsLambdaGlobal();
+        return aws?.streamifyResponse ? aws.streamifyResponse(handler) : handler;
+    }
+    return createAwsLambdaHttpDriver(http);
+}
+function createAwsLambdaHttpDriver(application) {
+    let initialization;
+    return async (event) => {
+        initialization ??= application.initialize();
+        await initialization;
+        const response = await application.handle(toRequest(event));
+        const metadata = responseMetadata(response);
+        return {
+            statusCode: response.status,
+            ...metadata,
+            body: Buffer.from(await response.arrayBuffer()).toString('base64'),
+            isBase64Encoded: true,
+        };
+    };
+}
+function createAwsLambdaStreamingHttpDriver(application) {
+    let initialization;
+    return async (event, output) => {
+        initialization ??= application.initialize();
+        await initialization;
+        const response = await application.handle(toRequest(event));
+        const metadata = responseMetadata(response);
+        const aws = awsLambdaGlobal();
+        const outputMetadata = {
+            statusCode: response.status,
+            headers: metadata.headers,
+            ...(metadata.cookies === undefined
+                ? {}
+                : { multiValueHeaders: { 'Set-Cookie': metadata.cookies } }),
+        };
+        const stream = aws?.HttpResponseStream?.from
+            ? aws.HttpResponseStream.from(output, outputMetadata)
+            : output;
+        if (stream === output) {
+            output.setMetadata?.({
+                statusCode: response.status,
+                ...metadata,
+            });
+        }
+        const reader = response.body?.getReader();
+        if (reader) {
+            while (true) {
+                const chunk = await reader.read();
+                if (chunk.done)
+                    break;
+                if (!stream.write(chunk.value) && stream.once) {
+                    await new Promise((resolve) => {
+                        stream.once?.('drain', resolve);
+                    });
+                }
+            }
+        }
+        stream.end();
+    };
+}
+function responseMetadata(response) {
+    const headers = Object.fromEntries([...response.headers.entries()].filter(([name]) => name !== 'set-cookie'));
+    const cookies = response.headers.getSetCookie();
+    return {
+        headers,
+        ...(cookies.length === 0 ? {} : { cookies }),
+    };
+}
+function toRequest(event) {
+    const path = event.rawPath ?? '/';
+    const query = event.rawQueryString ? `?${event.rawQueryString}` : '';
+    const body = event.body
+        ? event.isBase64Encoded
+            ? Buffer.from(event.body, 'base64')
+            : event.body
+        : undefined;
+    return new Request(`https://aws-lambda.local${path}${query}`, {
+        method: event.requestContext?.http?.method ?? 'GET',
+        headers: Object.fromEntries(Object.entries(event.headers ?? {}).filter((entry) => entry[1] !== undefined)),
+        ...(body === undefined ? {} : { body }),
+    });
+}
+function awsLambdaGlobal() {
+    return globalThis
+        .awslambda;
+}

package/dist/adapters/bun.d.ts

@@ -0,0 +1,20 @@
+import { type ApplicationDefinition, type BootstrapArguments, type HasHttp, type HostBindingApplication } from '../application/index.js';
+type IsAny<TValue> = 0 extends 1 & TValue ? true : false;
+type HttpApplication<TDefinition extends ApplicationDefinition> = IsAny<TDefinition> extends true ? TDefinition : HasHttp<TDefinition> extends true ? TDefinition : never;
+export type BunServeOptions<TDefinition extends ApplicationDefinition> = {
+    readonly application: HttpApplication<TDefinition>;
+    readonly port: number;
+    readonly hostname?: string;
+    readonly environment?: unknown;
+} & BootstrapArguments<TDefinition>;
+export interface BunServeHandle<TDefinition extends ApplicationDefinition = ApplicationDefinition> {
+    readonly application: HostBindingApplication<TDefinition>;
+    close(signal?: string): Promise<void>;
+}
+export declare const bunRuntime: {
+    readonly runtime: 'bun';
+    readonly capabilities: Set<string>;
+    readonly serve: typeof serve;
+};
+declare function serve<const TDefinition extends ApplicationDefinition>(options: BunServeOptions<TDefinition>): Promise<BunServeHandle<TDefinition>>;
+export {};

package/dist/adapters/bun.js

@@ -0,0 +1,82 @@
+import { binding, } from '../application/index.js';
+export const bunRuntime = {
+    runtime: 'bun',
+    capabilities: new Set([
+        'http.server',
+        'http.request.streaming',
+        'http.response.streaming',
+        'stream.readable',
+        'stream.writable',
+        'runtime.longLived',
+        'runtime.shutdownHook',
+        'env.runtime',
+        'crypto.random',
+    ]),
+    serve,
+};
+async function serve(options) {
+    const bun = bunGlobal();
+    if (!bun?.serve) {
+        throw new Error('LUTRE_BUN_UNAVAILABLE: Bun.serve() is not available.');
+    }
+    const host = binding.host({
+        application: options.application,
+        environment: 'environment' in options ? options.environment : (bun.env ?? undefined),
+        ...('arguments' in options ? { arguments: options.arguments } : {}),
+    });
+    const http = 'http' in host ? host.http : undefined;
+    if (!http) {
+        await host.application.close();
+        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: bunRuntime.serve() requires an HTTP-capable Application.');
+    }
+    await host.application.init();
+    if ('triggers' in host.application)
+        await host.application.triggers.start();
+    let server;
+    try {
+        server = bun.serve({
+            port: options.port,
+            ...(options.hostname === undefined ? {} : { hostname: options.hostname }),
+            fetch: createBunFetchDriver(http),
+        });
+    }
+    catch (error) {
+        await host.application.close().catch(() => undefined);
+        throw error;
+    }
+    let closed = false;
+    return {
+        application: host.application,
+        async close(signal) {
+            if (closed)
+                return;
+            closed = true;
+            const errors = [];
+            try {
+                await server.stop(true);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            try {
+                await host.application.close(signal);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            if (errors.length > 0)
+                throw new AggregateError(errors, 'Bun runtime shutdown failed');
+        },
+    };
+}
+function createBunFetchDriver(application) {
+    let initialization;
+    return async (request) => {
+        initialization ??= application.initialize();
+        await initialization;
+        return application.handle(request);
+    };
+}
+function bunGlobal() {
+    return globalThis.Bun;
+}

package/dist/adapters/cloudflare-workers.d.ts

@@ -0,0 +1,18 @@
+import { type ApplicationDefinition, type BootstrapArguments, type HasHttp } from '../application/index.js';
+type IsAny<TValue> = 0 extends 1 & TValue ? true : false;
+type HttpApplication<TDefinition extends ApplicationDefinition> = IsAny<TDefinition> extends true ? TDefinition : HasHttp<TDefinition> extends true ? TDefinition : never;
+export type CloudflareWorkersBindOptions<TDefinition extends ApplicationDefinition> = {
+    readonly application: HttpApplication<TDefinition>;
+} & BootstrapArguments<TDefinition>;
+export interface CloudflareWorkersBinding {
+    fetch(request: Request, environment?: unknown, executionContext?: unknown): Promise<Response>;
+    close(signal?: string): Promise<void>;
+}
+export declare const cloudflareWorkersRuntime: {
+    readonly runtime: 'cloudflare-workers';
+    readonly compatibilityDateMinimum: '2026-08-04';
+    readonly capabilities: Set<string>;
+    readonly bind: typeof bind;
+};
+declare function bind<const TDefinition extends ApplicationDefinition>(options: CloudflareWorkersBindOptions<TDefinition>): CloudflareWorkersBinding;
+export {};

package/dist/adapters/cloudflare-workers.js

@@ -0,0 +1,55 @@
+import { binding, } from '../application/index.js';
+export const cloudflareWorkersRuntime = {
+    runtime: 'cloudflare-workers',
+    compatibilityDateMinimum: '2026-08-04',
+    capabilities: new Set([
+        'http.server',
+        'http.request.streaming',
+        'http.response.streaming',
+        'stream.readable',
+        'stream.writable',
+        'background.waitUntil',
+        'env.runtime',
+        'crypto.random',
+    ]),
+    bind,
+};
+function bind(options) {
+    let invocation;
+    let fetch;
+    const resolve = (environment) => {
+        if (invocation && fetch)
+            return { invocation, fetch };
+        invocation = binding.invocation({
+            application: options.application,
+            environment,
+            ...('arguments' in options ? { arguments: options.arguments } : {}),
+        });
+        const http = 'http' in invocation
+            ? invocation.http
+            : undefined;
+        if (!http) {
+            void invocation.application.close();
+            throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: cloudflareWorkersRuntime.bind() requires an HTTP-capable Application.');
+        }
+        fetch = createCloudflareWorkersFetchDriver(http);
+        return { invocation, fetch };
+    };
+    return {
+        async fetch(request, environment) {
+            const resolved = resolve(environment);
+            return resolved.fetch(request);
+        },
+        async close(signal) {
+            await invocation?.application.close(signal);
+        },
+    };
+}
+function createCloudflareWorkersFetchDriver(application) {
+    let initialization;
+    return async (request) => {
+        initialization ??= application.initialize();
+        await initialization;
+        return application.handle(request);
+    };
+}

package/dist/adapters/deno.d.ts

@@ -0,0 +1,28 @@
+import { type ApplicationDefinition, type BootstrapArguments, type HasHttp, type HostBindingApplication } from '../application/index.js';
+type IsAny<TValue> = 0 extends 1 & TValue ? true : false;
+type HttpApplication<TDefinition extends ApplicationDefinition> = IsAny<TDefinition> extends true ? TDefinition : HasHttp<TDefinition> extends true ? TDefinition : never;
+export type DenoRuntimeOptions<TDefinition extends ApplicationDefinition> = {
+    readonly application: HttpApplication<TDefinition>;
+    readonly environment?: unknown;
+} & BootstrapArguments<TDefinition>;
+export type DenoServeOptions<TDefinition extends ApplicationDefinition> = DenoRuntimeOptions<TDefinition> & {
+    readonly port: number;
+    readonly hostname?: string;
+};
+export interface DenoBinding {
+    fetch(request: Request): Promise<Response>;
+    close(signal?: string): Promise<void>;
+}
+export interface DenoServeHandle<TDefinition extends ApplicationDefinition = ApplicationDefinition> {
+    readonly application: HostBindingApplication<TDefinition>;
+    close(signal?: string): Promise<void>;
+}
+export declare const denoRuntime: {
+    readonly runtime: 'deno';
+    readonly capabilities: Set<string>;
+    readonly bind: typeof bind;
+    readonly serve: typeof serve;
+};
+declare function bind<const TDefinition extends ApplicationDefinition>(options: DenoRuntimeOptions<TDefinition>): DenoBinding;
+declare function serve<const TDefinition extends ApplicationDefinition>(options: DenoServeOptions<TDefinition>): Promise<DenoServeHandle<TDefinition>>;
+export {};

package/dist/adapters/deno.js

@@ -0,0 +1,106 @@
+import { binding, } from '../application/index.js';
+export const denoRuntime = {
+    runtime: 'deno',
+    capabilities: new Set([
+        'http.server',
+        'http.request.streaming',
+        'http.response.streaming',
+        'stream.readable',
+        'stream.writable',
+        'runtime.longLived',
+        'runtime.shutdownHook',
+        'env.runtime',
+        'crypto.random',
+    ]),
+    bind,
+    serve,
+};
+function bind(options) {
+    const invocation = binding.invocation(bindingOptions(options, denoEnvironment()));
+    const http = 'http' in invocation
+        ? invocation.http
+        : undefined;
+    if (!http) {
+        void invocation.application.close();
+        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: denoRuntime.bind() requires an HTTP-capable Application.');
+    }
+    const fetch = createDenoFetchDriver(http);
+    return {
+        fetch,
+        close: (signal) => invocation.application.close(signal),
+    };
+}
+async function serve(options) {
+    const deno = denoGlobal();
+    if (!deno?.serve) {
+        throw new Error('LUTRE_DENO_UNAVAILABLE: Deno.serve() is not available.');
+    }
+    const host = binding.host(bindingOptions(options, denoEnvironment()));
+    const http = 'http' in host ? host.http : undefined;
+    if (!http) {
+        await host.application.close();
+        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: denoRuntime.serve() requires an HTTP-capable Application.');
+    }
+    await host.application.init();
+    if ('triggers' in host.application)
+        await host.application.triggers.start();
+    let server;
+    try {
+        server = deno.serve({
+            port: options.port,
+            ...(options.hostname === undefined
+                ? {}
+                : { hostname: options.hostname }),
+        }, createDenoFetchDriver(http));
+    }
+    catch (error) {
+        await host.application.close().catch(() => undefined);
+        throw error;
+    }
+    let closed = false;
+    return {
+        application: host.application,
+        async close(signal) {
+            if (closed)
+                return;
+            closed = true;
+            const errors = [];
+            try {
+                await server.shutdown();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            try {
+                await host.application.close(signal);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            if (errors.length > 0)
+                throw new AggregateError(errors, 'Deno runtime shutdown failed');
+        },
+    };
+}
+function createDenoFetchDriver(application) {
+    let initialization;
+    return async (request) => {
+        initialization ??= application.initialize();
+        await initialization;
+        return application.handle(request);
+    };
+}
+function bindingOptions(options, environment) {
+    return {
+        application: options.application,
+        environment: 'environment' in options ? options.environment : environment,
+        ...('arguments' in options ? { arguments: options.arguments } : {}),
+    };
+}
+function denoEnvironment() {
+    const deno = denoGlobal();
+    return deno?.env?.toObject ? deno.env.toObject() : undefined;
+}
+function denoGlobal() {
+    return globalThis.Deno;
+}

package/dist/adapters/electron.d.ts

@@ -0,0 +1,27 @@
+import { type ApplicationDefinition, type BootstrapArguments, type HasMessagePort, type InvocationApplication } from '../application/index.js';
+import { type MessagePortLike } from '../message-port/index.js';
+type IsAny<TValue> = 0 extends 1 & TValue ? true : false;
+type MessagePortApplication<TDefinition extends ApplicationDefinition> = IsAny<TDefinition> extends true ? TDefinition : HasMessagePort<TDefinition> extends true ? TDefinition : never;
+export interface ElectronMessagePortMainLike {
+    postMessage(value: unknown): void;
+    on(type: 'message', listener: (event: {
+        readonly data: unknown;
+    }) => void): void;
+    start(): void;
+}
+export type ElectronAttachOptions<TDefinition extends ApplicationDefinition> = {
+    readonly application: MessagePortApplication<TDefinition>;
+    readonly port: MessagePortLike | ElectronMessagePortMainLike;
+    readonly environment?: unknown;
+} & BootstrapArguments<TDefinition>;
+export interface ElectronAttachment<TDefinition extends ApplicationDefinition = ApplicationDefinition> {
+    readonly application: InvocationApplication<TDefinition>;
+    close(signal?: string): Promise<void>;
+}
+export declare const electronRuntime: {
+    readonly runtime: 'electron';
+    readonly capabilities: Set<string>;
+    readonly attach: typeof attach;
+};
+declare function attach<const TDefinition extends ApplicationDefinition>(options: ElectronAttachOptions<TDefinition>): ElectronAttachment<TDefinition>;
+export {};

package/dist/adapters/electron.js

@@ -0,0 +1,52 @@
+import { binding, } from '../application/index.js';
+import { attachMessagePort, } from '../message-port/index.js';
+export const electronRuntime = {
+    runtime: 'electron',
+    capabilities: new Set([
+        'messagePort.send',
+        'messagePort.receive',
+        'messagePort.transfer',
+        'stream.readable',
+        'runtime.longLived',
+        'runtime.shutdownHook',
+        'env.runtime',
+        'crypto.random',
+    ]),
+    attach,
+};
+function attach(options) {
+    const invocation = binding.invocation({
+        application: options.application,
+        environment: 'environment' in options
+            ? options.environment
+            : typeof process === 'undefined'
+                ? undefined
+                : process.env,
+        ...('arguments' in options ? { arguments: options.arguments } : {}),
+    });
+    const messagePort = 'messagePort' in invocation
+        ? invocation.messagePort
+        : undefined;
+    if (!messagePort) {
+        void invocation.application.close();
+        throw new Error('LUTRE_RUNTIME_MESSAGE_PORT_REQUIRED: electronRuntime.attach() requires a MessagePort-capable Application.');
+    }
+    attachElectronMessagePort(messagePort, options.port);
+    return {
+        application: invocation.application,
+        close: (signal) => invocation.application.close(signal),
+    };
+}
+function attachElectronMessagePort(application, port) {
+    const initialization = application.initialize();
+    void initialization.catch(() => undefined);
+    if ('addEventListener' in port) {
+        attachMessagePort(application, port);
+        return;
+    }
+    attachMessagePort(application, {
+        postMessage: (value) => port.postMessage(value),
+        addEventListener: (_type, listener) => port.on('message', listener),
+        start: () => port.start(),
+    });
+}

package/dist/application/binding.d.ts

@@ -0,0 +1,33 @@
+import { type ProviderDescriptor, type QueueDescriptor } from '../core/index.js';
+import { type HttpProtocolExecution } from '../http/index.js';
+import { type MessagePortProtocolExecution } from '../message-port/index.js';
+import type { ApplicationDefinition, BootstrapArguments, HasHttp, HasMessagePort, HasTriggers, InvocationApplication, QueueConsumerDriver, TriggerApplicationCapability } from './index.js';
+type IsAny<TValue> = 0 extends 1 & TValue ? true : false;
+type ProtocolBinding<TDefinition extends ApplicationDefinition> = IsAny<TDefinition> extends true ? {
+    readonly http?: HttpProtocolExecution;
+    readonly messagePort?: MessagePortProtocolExecution;
+} : (HasHttp<TDefinition> extends true ? {
+    readonly http: HttpProtocolExecution;
+} : {}) & (HasMessagePort<TDefinition> extends true ? {
+    readonly messagePort: MessagePortProtocolExecution;
+} : {});
+export type InvocationBinding<TDefinition extends ApplicationDefinition> = {
+    readonly application: InvocationApplication<TDefinition>;
+} & ProtocolBinding<TDefinition>;
+export type HostBindingApplication<TDefinition extends ApplicationDefinition> = InvocationApplication<TDefinition> & (HasTriggers<TDefinition> extends true ? TriggerApplicationCapability : {});
+export type HostBinding<TDefinition extends ApplicationDefinition> = {
+    readonly application: HostBindingApplication<TDefinition>;
+} & ProtocolBinding<TDefinition>;
+export interface InvocationBindingBaseOptions<TDefinition extends ApplicationDefinition> {
+    readonly application: TDefinition;
+    readonly environment?: unknown;
+}
+export type InvocationBindingOptions<TDefinition extends ApplicationDefinition> = InvocationBindingBaseOptions<TDefinition> & BootstrapArguments<TDefinition>;
+interface BindingApi {
+    invocation<const TDefinition extends ApplicationDefinition>(options: InvocationBindingOptions<TDefinition>): InvocationBinding<TDefinition>;
+    host<const TDefinition extends ApplicationDefinition>(options: InvocationBindingOptions<TDefinition>): HostBinding<TDefinition>;
+    queue(descriptor: QueueDescriptor, driver: QueueConsumerDriver): ProviderDescriptor;
+}
+/** flatなcreateXXX/bindXXX APIを増殖させないため、外部bindingをnamespaceへ集約する。 */
+export declare const binding: Readonly<BindingApi>;
+export {};