@loutrejs/loutre 0.1.0

package/dist/application/openapi.js

@@ -0,0 +1,362 @@
+import { supportsJsonSchema, } from '../core/index.js';
+import { assertValidCompilation, compileApplication } from '../graph/index.js';
+import { httpRequestBodyContentType, httpRequestBodySchema, } from '../http/index.js';
+const FIXED_METHODS = new Set([
+    'get',
+    'put',
+    'post',
+    'delete',
+    'options',
+    'head',
+    'patch',
+    'trace',
+    'query',
+]);
+export function generateOpenApi(application, options) {
+    const graph = assertValidCompilation(compileApplication({
+        modules: application.modules,
+        ...(application.arguments === undefined
+            ? {}
+            : { arguments: application.arguments }),
+        tasks: application.tasks,
+        triggers: application.triggers,
+    }));
+    const executable = new Set(graph.executions
+        .filter((execution) => execution.kind === 'protocol' && execution.protocol === 'http')
+        .map((execution) => execution.kind === 'protocol'
+        ? `${execution.implementation}\u0000${execution.procedure}`
+        : ''));
+    const registry = new SchemaRegistry();
+    const paths = {};
+    const operationIds = new Set();
+    for (const module of collectModules(application.modules)) {
+        for (const implementation of module.definition.implementations ?? []) {
+            if (implementation.protocol !== 'http')
+                continue;
+            for (const procedure of implementation.procedures) {
+                if (!executable.has(`${implementation.name}\u0000${procedure}`))
+                    continue;
+                const protocol = implementation.contract.procedures[procedure]?.protocols.http;
+                if (!protocol || protocol.protocol !== 'http')
+                    continue;
+                const typed = protocol;
+                const target = {
+                    definition: typed.definition,
+                    ...(implementation.contract.name === undefined
+                        ? {}
+                        : { contractName: implementation.contract.name }),
+                    procedure,
+                };
+                const operation = createOperation(target, registry, operationIds);
+                attachOperation(paths, typed.definition, operation);
+            }
+        }
+    }
+    const schemas = registry.components();
+    return {
+        openapi: '3.2.0',
+        jsonSchemaDialect: 'https://json-schema.org/draft/2020-12/schema',
+        info: options.info,
+        ...(options.servers === undefined ? {} : { servers: options.servers }),
+        paths,
+        ...(Object.keys(schemas).length === 0 ? {} : { components: { schemas } }),
+    };
+}
+function createOperation(target, registry, operationIds) {
+    const definition = target.definition;
+    const operationId = target.contractName
+        ? `${target.contractName}.${target.procedure}`
+        : undefined;
+    if (operationId) {
+        if (operationIds.has(operationId)) {
+            throw openApiError('LUTRE_OPENAPI_OPERATION_ID_001', `Duplicate operationId: ${operationId}`);
+        }
+        operationIds.add(operationId);
+    }
+    const parameters = [];
+    const request = definition.request;
+    if (request?.params) {
+        for (const [name, schema] of Object.entries(request.params)) {
+            parameters.push({
+                name,
+                in: 'path',
+                required: true,
+                schema: registry.reference(schema, 'input', componentName(target, `RequestParam_${name}_Input`)),
+            });
+        }
+    }
+    if (request?.query) {
+        parameters.push({
+            in: 'querystring',
+            content: {
+                'application/x-www-form-urlencoded': {
+                    schema: registry.reference(request.query, 'input', componentName(target, 'RequestQuery_Input')),
+                },
+            },
+        });
+    }
+    if (request?.headers) {
+        parameters.push(...headerParameters(request.headers, registry, target, 'RequestHeaders_Input'));
+    }
+    const requestBody = request?.body
+        ? createRequestBody(request.body, registry, target)
+        : undefined;
+    return {
+        ...(definition.tags === undefined ? {} : { tags: definition.tags }),
+        ...(definition.summary === undefined
+            ? {}
+            : { summary: definition.summary }),
+        ...(definition.description === undefined
+            ? {}
+            : { description: definition.description }),
+        ...(operationId === undefined ? {} : { operationId }),
+        ...(parameters.length === 0 ? {} : { parameters }),
+        ...(requestBody === undefined ? {} : { requestBody }),
+        responses: createResponses(target, registry),
+        ...(definition.deprecated === undefined
+            ? {}
+            : { deprecated: definition.deprecated }),
+    };
+}
+function createRequestBody(body, registry, target) {
+    const contentType = httpRequestBodyContentType(body);
+    return {
+        content: {
+            [contentType]: {
+                schema: registry.reference(httpRequestBodySchema(body), 'input', componentName(target, 'RequestBody_Input')),
+            },
+        },
+    };
+}
+function createResponses(target, registry) {
+    const grouped = new Map();
+    for (const [variant, response] of Object.entries(target.definition.responses)) {
+        const current = grouped.get(response.status) ?? [];
+        current.push({ variant, response });
+        grouped.set(response.status, current);
+    }
+    return Object.fromEntries([...grouped.entries()]
+        .toSorted(([left], [right]) => left - right)
+        .map(([status, entries]) => [
+        String(status),
+        createResponse(target, entries, registry),
+    ]));
+}
+function createResponse(target, entries, registry) {
+    const streamKinds = new Set(entries.map(({ response }) => response.stream === 'server'));
+    if (streamKinds.size > 1) {
+        throw openApiError('LUTRE_OPENAPI_RESPONSE_STREAM_001', `${describeTarget(target)} declares streaming and non-streaming responses with the same status.`);
+    }
+    const schemas = entries.map(({ variant, response }) => registry.reference(response.body, 'output', componentName(target, `Response_${variant}_Output`)));
+    const payloadSchema = schemas.length === 1 ? schemas[0] : { oneOf: schemas };
+    const streaming = entries[0]?.response.stream === 'server';
+    const headers = mergeResponseHeaders(entries, registry, target);
+    const descriptions = [
+        ...new Set(entries.map(({ variant, response }) => response.description ?? variant)),
+    ];
+    return {
+        description: descriptions.join(' / '),
+        ...(headers === undefined ? {} : { headers }),
+        content: streaming
+            ? {
+                'text/event-stream': {
+                    itemSchema: {
+                        type: 'object',
+                        required: ['data'],
+                        properties: {
+                            data: {
+                                type: 'string',
+                                contentMediaType: 'application/json',
+                                contentSchema: payloadSchema,
+                            },
+                        },
+                    },
+                },
+            }
+            : {
+                'application/json': {
+                    schema: payloadSchema,
+                },
+            },
+    };
+}
+function mergeResponseHeaders(entries, registry, target) {
+    const result = new Map();
+    for (const { variant, response } of entries) {
+        if (!response.headers)
+            continue;
+        const materialized = registry.materialize(response.headers, 'output', componentName(target, `Response_${variant}_Headers_Output`));
+        const properties = objectProperties(materialized.schema, 'LUTRE_OPENAPI_HEADER_SCHEMA_001', `${describeTarget(target)} response headers`);
+        for (const [name, schema] of Object.entries(properties)) {
+            const current = result.get(name) ?? [];
+            current.push(schema);
+            result.set(name, current);
+        }
+    }
+    if (result.size === 0)
+        return undefined;
+    return Object.fromEntries([...result.entries()].map(([name, schemas]) => [
+        name,
+        {
+            schema: schemas.length === 1
+                ? schemas[0]
+                : { oneOf: dedupeJsonSchemas(schemas) },
+        },
+    ]));
+}
+function headerParameters(schema, registry, target, suffix) {
+    const materialized = registry.materialize(schema, 'input', componentName(target, suffix));
+    const properties = objectProperties(materialized.schema, 'LUTRE_OPENAPI_HEADER_SCHEMA_001', `${describeTarget(target)} request headers`);
+    const required = new Set(Array.isArray(materialized.schema.required)
+        ? materialized.schema.required.filter((value) => typeof value === 'string')
+        : []);
+    return Object.entries(properties).map(([name, propertySchema]) => ({
+        name,
+        in: 'header',
+        required: required.has(name),
+        schema: propertySchema,
+    }));
+}
+function objectProperties(schema, code, description) {
+    const properties = schema.properties;
+    if (schema.type !== 'object' ||
+        typeof properties !== 'object' ||
+        properties === null ||
+        Array.isArray(properties)) {
+        throw openApiError(code, `${description} must convert to an object JSON Schema with properties.`);
+    }
+    return properties;
+}
+function attachOperation(paths, definition, operation) {
+    const path = definition.path;
+    const pathItem = (paths[path] ??= {});
+    const method = definition.method.toLowerCase();
+    if (FIXED_METHODS.has(method)) {
+        if (pathItem[method] !== undefined) {
+            throw openApiError('LUTRE_OPENAPI_OPERATION_001', `Duplicate OpenAPI operation: ${definition.method.toUpperCase()} ${path}`);
+        }
+        pathItem[method] = operation;
+        return;
+    }
+    const additional = (pathItem.additionalOperations ??= {});
+    const methodName = definition.method.toUpperCase();
+    if (additional[methodName] !== undefined) {
+        throw openApiError('LUTRE_OPENAPI_OPERATION_001', `Duplicate OpenAPI operation: ${methodName} ${path}`);
+    }
+    additional[methodName] = operation;
+}
+function collectModules(roots) {
+    const result = [];
+    const seen = new Set();
+    const visit = (module) => {
+        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;
+}
+class SchemaRegistry {
+    bySchema = new Map();
+    schemas = {};
+    reference(schema, direction, preferredName) {
+        return this.materialize(schema, direction, preferredName).reference;
+    }
+    materialize(schema, direction, preferredName) {
+        const existing = this.bySchema.get(schema)?.[direction];
+        if (existing)
+            return existing;
+        if (!supportsJsonSchema(schema)) {
+            throw openApiError('LUTRE_OPENAPI_SCHEMA_001', `${preferredName} does not implement StandardJSONSchemaV1.`);
+        }
+        let converted;
+        try {
+            converted = schema['~standard'].jsonSchema[direction]({
+                target: 'draft-2020-12',
+            });
+        }
+        catch (error) {
+            throw openApiError('LUTRE_OPENAPI_SCHEMA_002', `${preferredName} could not be converted to draft-2020-12 JSON Schema: ${errorMessage(error)}`);
+        }
+        const name = uniqueComponentName(preferredName, this.schemas);
+        const rebased = rebaseLocalDefinitions(converted, name);
+        this.schemas[name] = rebased;
+        const materialized = {
+            name,
+            schema: rebased,
+            reference: { $ref: `#/components/schemas/${escapeJsonPointer(name)}` },
+        };
+        const directions = this.bySchema.get(schema) ?? {};
+        directions[direction] = materialized;
+        this.bySchema.set(schema, directions);
+        return materialized;
+    }
+    components() {
+        return this.schemas;
+    }
+}
+function rebaseLocalDefinitions(schema, schemaComponentName) {
+    const visit = (value) => {
+        if (Array.isArray(value))
+            return value.map(visit);
+        if (typeof value !== 'object' || value === null)
+            return value;
+        const result = {};
+        for (const [key, child] of Object.entries(value)) {
+            if (key === '$ref' &&
+                typeof child === 'string' &&
+                child.startsWith('#/$defs/')) {
+                result[key] =
+                    `#/components/schemas/${escapeJsonPointer(schemaComponentName)}/$defs/${child.slice('#/$defs/'.length)}`;
+            }
+            else {
+                result[key] = visit(child);
+            }
+        }
+        return result;
+    };
+    return visit(schema);
+}
+function componentName(target, suffix) {
+    return sanitizeComponentName(`${target.contractName ?? 'AnonymousContract'}_${target.procedure}_${suffix}`);
+}
+function sanitizeComponentName(value) {
+    const sanitized = value.replace(/[^A-Za-z0-9_.-]+/g, '_');
+    return sanitized.length === 0 ? 'Schema' : sanitized;
+}
+function uniqueComponentName(preferred, schemas) {
+    if (!(preferred in schemas))
+        return preferred;
+    let index = 2;
+    while (`${preferred}_${index}` in schemas)
+        index += 1;
+    return `${preferred}_${index}`;
+}
+function escapeJsonPointer(value) {
+    return value.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+function describeTarget(target) {
+    return `${target.contractName ?? 'AnonymousContract'}.${target.procedure}`;
+}
+function dedupeJsonSchemas(schemas) {
+    const seen = new Set();
+    const result = [];
+    for (const schema of schemas) {
+        const serialized = JSON.stringify(schema);
+        if (seen.has(serialized))
+            continue;
+        seen.add(serialized);
+        result.push(schema);
+    }
+    return result;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function openApiError(code, message) {
+    return new Error(`${code}: ${message}`);
+}

package/dist/application/queue.d.ts

@@ -0,0 +1,3 @@
+import { type ProviderDescriptor, type QueueDescriptor } from '../core/index.js';
+import type { QueueConsumerDriver } from './index.js';
+export declare function bindQueueDriver(queue: QueueDescriptor, driver: QueueConsumerDriver): ProviderDescriptor;

package/dist/application/queue.js

@@ -0,0 +1,4 @@
+import { provide, queueRuntimeToken, } from '../core/index.js';
+export function bindQueueDriver(queue, driver) {
+    return provide(queueRuntimeToken(queue)).useValue(driver);
+}

package/dist/application/scheduler.d.ts

@@ -0,0 +1,2 @@
+import type { CronTriggerDescriptor } from '../core/index.js';
+export declare function matchesCronTrigger(trigger: CronTriggerDescriptor<any>, instant: Date): boolean;

package/dist/application/scheduler.js

@@ -0,0 +1,45 @@
+export function matchesCronTrigger(trigger, instant) {
+    const [minute, hour, dayOfMonth, month, dayOfWeek] = trigger.expression
+        .trim()
+        .split(/\s+/);
+    const fields = { minute, hour, dayOfMonth, month, dayOfWeek };
+    const parts = new Intl.DateTimeFormat('en-US', {
+        timeZone: trigger.timezone,
+        minute: 'numeric',
+        hour: 'numeric',
+        day: 'numeric',
+        month: 'numeric',
+        weekday: 'short',
+        hourCycle: 'h23',
+    }).formatToParts(instant);
+    const value = (type) => parts.find((part) => part.type === type)?.value ?? '';
+    const weekday = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'].indexOf(value('weekday'));
+    return (matchesCronField(fields.minute, Number(value('minute')), 0, 59) &&
+        matchesCronField(fields.hour, Number(value('hour')), 0, 23) &&
+        matchesCronField(fields.dayOfMonth, Number(value('day')), 1, 31) &&
+        matchesCronField(fields.month, Number(value('month')), 1, 12) &&
+        matchesCronField(fields.dayOfWeek, weekday, 0, 7, true));
+}
+function matchesCronField(expression, value, minimum, maximum, sundayAlias = false) {
+    return expression.split(',').some((segment) => {
+        const [rangeExpression, stepExpression] = segment.split('/');
+        const step = stepExpression === undefined ? 1 : Number(stepExpression);
+        if (!Number.isInteger(step) || step <= 0 || !rangeExpression)
+            return false;
+        let start = minimum;
+        let end = maximum;
+        if (rangeExpression !== '*') {
+            const [startExpression, endExpression] = rangeExpression.split('-');
+            start = Number(startExpression);
+            end = endExpression === undefined ? start : Number(endExpression);
+        }
+        const normalized = sundayAlias && value === 0 && start === 7 ? 7 : value;
+        return (Number.isInteger(start) &&
+            Number.isInteger(end) &&
+            start >= minimum &&
+            end <= maximum &&
+            normalized >= start &&
+            normalized <= end &&
+            (normalized - start) % step === 0);
+    });
+}

package/dist/core/args.d.ts

@@ -0,0 +1,16 @@
+import type { Class } from './token.js';
+import { type SchemaOutput, type StandardSchemaV1 } from './schema.js';
+import type { RuntimeInputKey } from './runtime-input.js';
+export type ArgsSchema = StandardSchemaV1<unknown, object>;
+export type ArgsKey<TValue = unknown> = RuntimeInputKey<TValue> & {
+    readonly source: 'arguments';
+    readonly contract: ArgsClass;
+};
+export interface ArgsClass<TSchema extends ArgsSchema = ArgsSchema> extends Class<SchemaOutput<TSchema>> {
+    readonly kind: 'arguments';
+    readonly schema: TSchema;
+    key<TKey extends keyof SchemaOutput<TSchema> & string>(key: TKey): ArgsKey<SchemaOutput<TSchema>[TKey]>;
+}
+export declare function defineArgs<TSchema extends ArgsSchema>(schema: TSchema): ArgsClass<TSchema>;
+export declare function isArgsClass(value: unknown): value is ArgsClass;
+export declare function loadArgs<TSchema extends ArgsSchema>(Args: ArgsClass<TSchema>, source: unknown): Promise<InstanceType<ArgsClass<TSchema>>>;

package/dist/core/args.js

@@ -0,0 +1,29 @@
+import { validateSchema, } from './schema.js';
+export function defineArgs(schema) {
+    class DefinedArgs {
+        static kind = 'arguments';
+        static schema = schema;
+        static key(key) {
+            return {
+                kind: 'runtime-input-key',
+                source: 'arguments',
+                contract: this,
+                key,
+            };
+        }
+        constructor(values) {
+            Object.assign(this, values);
+        }
+    }
+    return DefinedArgs;
+}
+export function isArgsClass(value) {
+    return (typeof value === 'function' &&
+        value.kind === 'arguments' &&
+        'schema' in value &&
+        typeof value.key === 'function');
+}
+export async function loadArgs(Args, source) {
+    const values = await validateSchema(Args.schema, source);
+    return new Args(values);
+}

package/dist/core/context-key.d.ts

@@ -0,0 +1,14 @@
+export interface ContextKey<TName extends string = string, TValue = unknown> {
+    readonly kind: 'context-key';
+    readonly name: TName;
+    readonly key: symbol;
+    readonly '~value'?: TValue;
+}
+export type ContextKeyValue<TKey> = TKey extends ContextKey<string, infer TValue> ? TValue : never;
+export type ContextProperties<TKeys extends readonly ContextKey[]> = {
+    readonly [TKey in TKeys[number] as TKey['name']]: ContextKeyValue<TKey>;
+};
+export declare function contextKey<const TName extends string>(name: TName): {
+    of<TValue>(): ContextKey<TName, TValue>;
+};
+export declare function contextKeyName(key: ContextKey): string;

package/dist/core/context-key.js

@@ -0,0 +1,14 @@
+export function contextKey(name) {
+    return {
+        of() {
+            return Object.freeze({
+                kind: 'context-key',
+                name,
+                key: Symbol(name),
+            });
+        },
+    };
+}
+export function contextKeyName(key) {
+    return key.name;
+}

package/dist/core/contract.d.ts

@@ -0,0 +1,54 @@
+export interface ProtocolDescriptor<TName extends string = string, TContext = unknown, TResult = unknown, TDispatchKey extends string | null = string | null, TCapabilities extends readonly string[] = readonly string[]> {
+    readonly kind: 'protocol';
+    readonly protocol: TName;
+    readonly interaction?: InteractionMode;
+    readonly dispatchKey: TDispatchKey;
+    readonly capabilities?: TCapabilities;
+    readonly '~context'?: TContext;
+    readonly '~result'?: TResult;
+}
+export type InteractionMode = 'unary' | 'server-stream' | 'client-stream' | 'duplex';
+export interface ProcedureDefinition<TProtocols extends Record<string, ProtocolDescriptor> = Record<string, ProtocolDescriptor>> {
+    readonly kind: 'procedure';
+    readonly protocols: TProtocols;
+}
+export declare function procedure<const TProtocols extends Record<string, ProtocolDescriptor>>(definition: {
+    readonly protocols: TProtocols;
+}): ProcedureDefinition<TProtocols>;
+export interface ContractDefinition<TProcedures extends Record<string, ProcedureDefinition> = Record<string, ProcedureDefinition>> {
+    readonly kind: 'contract';
+    readonly name?: string;
+    readonly procedures: TProcedures;
+}
+export declare function contract<const TProcedures extends Record<string, ProcedureDefinition>>(procedures: TProcedures & DispatchKeyUniquenessConstraint<TProcedures>, options?: {
+    readonly name?: string;
+}): ContractDefinition<TProcedures>;
+type ProtocolDispatchEntries<TProcedures extends Record<string, ProcedureDefinition>> = {
+    [TProcedure in keyof TProcedures & string]: {
+        [TProtocol in keyof TProcedures[TProcedure]['protocols'] & string]: TProcedures[TProcedure]['protocols'][TProtocol] extends {
+            readonly dispatchKey: infer TDispatchKey extends string | null;
+        } ? TDispatchKey extends string ? {
+            readonly key: TDispatchKey;
+            readonly path: `${TProcedure}.${TProtocol}`;
+        } : never : never;
+    }[keyof TProcedures[TProcedure]['protocols'] & string];
+}[keyof TProcedures & string];
+type IsUnion<TValue, TCandidate = TValue> = TValue extends unknown ? [TCandidate] extends [TValue] ? false : true : never;
+type DuplicateDispatchKeys<TEntries, TAllEntries = TEntries> = TEntries extends {
+    readonly key: infer TKey extends string;
+} ? string extends TKey ? never : IsUnion<Extract<TAllEntries, {
+    readonly key: TKey;
+}> extends {
+    readonly path: infer TPath;
+} ? TPath : never> extends true ? TKey : never : never;
+type DispatchKeyUniquenessConstraint<TProcedures extends Record<string, ProcedureDefinition>> = [DuplicateDispatchKeys<ProtocolDispatchEntries<TProcedures>>] extends [
+    never
+] ? unknown : {
+    readonly __duplicateProtocolDispatchKey__: DuplicateDispatchKeys<ProtocolDispatchEntries<TProcedures>>;
+};
+export type ContractProcedures<TContract extends ContractDefinition> = TContract['procedures'];
+export interface ProtocolFactory<TName extends string, TCapabilities extends readonly string[] = readonly string[]> {
+    readonly protocol: TName;
+    readonly capabilities?: TCapabilities;
+}
+export {};

package/dist/core/contract.js

@@ -0,0 +1,30 @@
+export function procedure(definition) {
+    return { kind: 'procedure', protocols: definition.protocols };
+}
+export function contract(procedures, options = {}) {
+    assertUniqueDispatchKeys(procedures, options.name);
+    return {
+        kind: 'contract',
+        ...(options.name === undefined ? {} : { name: options.name }),
+        procedures,
+    };
+}
+function assertUniqueDispatchKeys(procedures, contractName) {
+    const paths = new Map();
+    for (const [procedureName, procedureDefinition] of Object.entries(procedures)) {
+        for (const [protocolName, protocol] of Object.entries(procedureDefinition.protocols)) {
+            const dispatchKey = protocol.dispatchKey;
+            if (dispatchKey === null)
+                continue;
+            if (typeof dispatchKey !== 'string') {
+                throw new Error(`Protocol dispatchKey must be a string or null: ${procedureName}.${protocolName}`);
+            }
+            const path = `${contractName ?? 'Contract'}.${procedureName}.${protocolName}`;
+            const existing = paths.get(dispatchKey);
+            if (existing) {
+                throw new Error(`Duplicate protocol dispatch key "${dispatchKey}" between ${existing} and ${path}`);
+            }
+            paths.set(dispatchKey, path);
+        }
+    }
+}

package/dist/core/env.d.ts

@@ -0,0 +1,16 @@
+import type { Class } from './token.js';
+import { type SchemaOutput, type StandardSchemaV1 } from './schema.js';
+import type { RuntimeInputKey } from './runtime-input.js';
+export type EnvSchema = StandardSchemaV1<unknown, object>;
+export type EnvKey<TValue = unknown> = RuntimeInputKey<TValue> & {
+    readonly source: 'environment';
+    readonly contract: EnvClass;
+};
+export interface EnvClass<TSchema extends EnvSchema = EnvSchema> extends Class<SchemaOutput<TSchema>> {
+    readonly kind: 'environment';
+    readonly schema: TSchema;
+    key<TKey extends keyof SchemaOutput<TSchema> & string>(key: TKey): EnvKey<SchemaOutput<TSchema>[TKey]>;
+}
+export declare function defineEnv<TSchema extends EnvSchema>(schema: TSchema): EnvClass<TSchema>;
+export declare function isEnvClass(value: unknown): value is EnvClass;
+export declare function loadEnv<TSchema extends EnvSchema>(Env: EnvClass<TSchema>, source: unknown): Promise<InstanceType<EnvClass<TSchema>>>;

package/dist/core/env.js

@@ -0,0 +1,29 @@
+import { validateSchema, } from './schema.js';
+export function defineEnv(schema) {
+    class DefinedEnv {
+        static kind = 'environment';
+        static schema = schema;
+        static key(key) {
+            return {
+                kind: 'runtime-input-key',
+                source: 'environment',
+                contract: this,
+                key,
+            };
+        }
+        constructor(values) {
+            Object.assign(this, values);
+        }
+    }
+    return DefinedEnv;
+}
+export function isEnvClass(value) {
+    return (typeof value === 'function' &&
+        value.kind === 'environment' &&
+        'schema' in value &&
+        typeof value.key === 'function');
+}
+export async function loadEnv(Env, source) {
+    const values = await validateSchema(Env.schema, source);
+    return new Env(values);
+}

package/dist/core/error.d.ts

@@ -0,0 +1,24 @@
+import type { SchemaOutput, StandardSchemaV1 } from './schema.js';
+declare const domainErrorMarker: unique symbol;
+export declare class DomainError<TData = unknown> extends Error {
+    readonly code: string;
+    readonly data: TData;
+    readonly [domainErrorMarker] = true;
+    constructor(code: string, data: TData, options?: {
+        readonly cause?: unknown;
+    });
+}
+export interface ErrorDefinition<TCode extends string = string, TSchema extends StandardSchemaV1 = StandardSchemaV1> {
+    (data: SchemaOutput<TSchema>, options?: {
+        readonly cause?: unknown;
+    }): DomainError<SchemaOutput<TSchema>>;
+    readonly kind: 'error-definition';
+    readonly code: TCode;
+    readonly data: TSchema;
+    is(error: unknown): error is DomainError<SchemaOutput<TSchema>>;
+}
+export declare function defineError<const TCode extends string, TSchema extends StandardSchemaV1>(definition: {
+    readonly code: TCode;
+    readonly data: TSchema;
+}): ErrorDefinition<TCode, TSchema>;
+export {};