@michaelthielemann/kestrel 4.1.3 → 5.0.2

package/dist/context.d.ts

@@ -0,0 +1,62 @@
+import { type CoreCode, type KestrelError } from "./errors.ts";
+import { type Err, type Ok, type Result } from "./result.ts";
+export type TriggerKind = "http" | "event" | "cron";
+export interface Trigger {
+    kind: TriggerKind;
+    name: string;
+}
+declare global {
+    namespace Kestrel {
+        interface ContextExtensions {
+        }
+    }
+}
+export interface UploadedFile {
+    field: string;
+    filename: string;
+    contentType: string;
+    data: Uint8Array;
+}
+export interface BinaryResult {
+    binary: true;
+    data: Uint8Array;
+    contentType: string;
+    filename?: string;
+    headers?: Record<string, string>;
+}
+export declare function binaryResult(data: Uint8Array, contentType: string, filename?: string): BinaryResult;
+export declare function isBinaryResult(value: unknown): value is BinaryResult;
+export interface Context extends Kestrel.ContextExtensions {
+    readonly runId: string;
+    requestId?: string;
+    trigger: Trigger;
+    payload: Record<string, unknown>;
+    params: Record<string, string>;
+    headers: Record<string, string>;
+    files: UploadedFile[];
+    ip?: string;
+    result?: unknown;
+    fail(code: CoreCode, message: string, details?: Record<string, unknown>): Err<KestrelError>;
+    fail(error: KestrelError): Err<KestrelError>;
+    done(result: unknown): Ok<Context>;
+}
+export type StepResult = Result<Context, KestrelError>;
+export type Step = (ctx: Context) => Promise<StepResult>;
+export type StepFactory = (arg: string) => Step;
+export type StepMap = Record<string, Step | StepFactory>;
+export declare const DONE: unique symbol;
+/** A Step and a StepFactory are both 1-ary functions; only this brand tells them apart at boot. */
+export declare function stepFactory<F extends StepFactory>(factory: F): F;
+export declare function isStepFactory(fn: unknown): fn is StepFactory;
+export interface ContextInput {
+    trigger: Trigger;
+    parentRunId?: string;
+    payload?: Record<string, unknown>;
+    params?: Record<string, string>;
+    headers?: Record<string, string>;
+    files?: UploadedFile[];
+    ip?: string;
+}
+export declare function first(value: unknown): string | undefined;
+export declare function requestIdOf(value: unknown): string | undefined;
+export declare function createContext(input: ContextInput, runId?: string): Context;

package/dist/context.js

@@ -0,0 +1,61 @@
+import { randomUUID } from "node:crypto";
+import { failure } from "./errors.js";
+import { err, ok } from "./result.js";
+export function binaryResult(data, contentType, filename) {
+    const result = { binary: true, data, contentType };
+    if (filename !== undefined)
+        result.filename = filename;
+    return result;
+}
+export function isBinaryResult(value) {
+    return typeof value === "object" && value !== null && value.binary === true && value.data instanceof Uint8Array;
+}
+export const DONE = Symbol.for("kestrel.done");
+const FACTORY = Symbol.for("kestrel.stepFactory");
+/** A Step and a StepFactory are both 1-ary functions; only this brand tells them apart at boot. */
+export function stepFactory(factory) {
+    Object.defineProperty(factory, FACTORY, { value: true });
+    return factory;
+}
+export function isStepFactory(fn) {
+    return typeof fn === "function" && Reflect.get(fn, FACTORY) === true;
+}
+export function first(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value) && typeof value[0] === "string")
+        return value[0];
+    return undefined;
+}
+/** The value is echoed into a response header, so anything but short printable ASCII is dropped. */
+const REQUEST_ID = /^[\x20-\x7e]{1,200}$/;
+export function requestIdOf(value) {
+    const id = first(value);
+    return id !== undefined && REQUEST_ID.test(id) ? id : undefined;
+}
+export function createContext(input, runId = randomUUID()) {
+    const ctx = {
+        runId,
+        trigger: input.trigger,
+        payload: input.payload ?? {},
+        params: input.params ?? {},
+        headers: input.headers ?? {},
+        files: input.files ?? [],
+        fail(codeOrError, message, details) {
+            if (typeof codeOrError !== "string")
+                return err(codeOrError);
+            return err(failure(codeOrError, message ?? "", details === undefined ? {} : { details }));
+        },
+        done(result) {
+            const next = { ...this, result };
+            Object.defineProperty(next, DONE, { value: true });
+            return ok(Object.freeze(next));
+        },
+    };
+    if (input.ip !== undefined)
+        ctx.ip = input.ip;
+    const requestId = requestIdOf(input.headers?.["x-request-id"]);
+    if (requestId !== undefined)
+        ctx.requestId = requestId;
+    return Object.freeze(ctx);
+}

package/dist/dataflow.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedPipeline } from "./runner.ts";
+import type { Route } from "./triggers/http.ts";
+export declare function checkDataflow(pipeline: ResolvedPipeline, httpRoutes: readonly Route[], hasCronTrigger: boolean, hasEventTrigger: boolean): void;

package/dist/dataflow.js

@@ -0,0 +1,65 @@
+import { KestrelBootError } from "./errors.js";
+const CONTEXT_KEYS = ["payload", "headers", "files", "ip", "params"];
+function routeParams(route) {
+    const names = new Set();
+    for (const segment of route.segments) {
+        if (segment.startsWith(":") || segment.startsWith("*"))
+            names.add(segment.slice(1));
+    }
+    return names;
+}
+/** Only a param every route binds is guaranteed to be there, whichever route served the run. */
+function commonParams(routes) {
+    const [first, ...rest] = routes;
+    if (first === undefined)
+        return [];
+    return [...routeParams(first)].filter((name) => rest.every((route) => routeParams(route).has(name)));
+}
+function satisfied(read, available) {
+    if (available.has(read))
+        return true;
+    for (const written of available) {
+        if (read.startsWith(`${written}.`) || written.startsWith(`${read}.`))
+            return true;
+    }
+    return false;
+}
+/** A plain write of a parent path replaces whatever was written under it. */
+function apply(write, sets) {
+    if (write.endsWith("?"))
+        return;
+    for (const set of sets) {
+        for (const existing of [...set]) {
+            if (existing.startsWith(`${write}.`))
+                set.delete(existing);
+        }
+        set.add(write);
+    }
+}
+export function checkDataflow(pipeline, httpRoutes, hasCronTrigger, hasEventTrigger) {
+    const available = new Set(CONTEXT_KEYS);
+    for (const param of commonParams(httpRoutes))
+        available.add(`params.${param}`);
+    const written = new Set();
+    for (const step of pipeline.steps) {
+        for (const read of step.description.reads) {
+            // The client owns the payload; the dev validator checks it against describe().input instead.
+            if (read.startsWith("payload."))
+                continue;
+            let ok;
+            if (read.startsWith("params.")) {
+                // An event envelope carries opaque params, so it can satisfy any of them; a pipeline with
+                // no trigger at all is only reachable through run(), where the caller supplies them.
+                ok = available.has(read) || hasEventTrigger || (httpRoutes.length === 0 && !hasCronTrigger);
+            }
+            else {
+                ok = satisfied(read, available);
+            }
+            if (!ok) {
+                throw new KestrelBootError(`pipelines/${pipeline.name}`, `step "${step.name}" reads "${read}" but no earlier step writes it (earlier writes: ${written.size === 0 ? "none" : [...written].join(", ")})`);
+            }
+        }
+        for (const write of step.description.writes)
+            apply(write, [available, written]);
+    }
+}

package/dist/defineConfig.d.ts

@@ -0,0 +1,162 @@
+import { z } from "zod";
+export declare const configSchema: z.ZodObject<{
+    modules: z.ZodArray<z.ZodObject<{
+        use: z.ZodString;
+        config: z.ZodOptional<z.ZodUnknown>;
+    }, "strict", z.ZodTypeAny, {
+        use: string;
+        config?: unknown;
+    }, {
+        use: string;
+        config?: unknown;
+    }>, "many">;
+    triggers: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        http: z.ZodString;
+        pipeline: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        http: string;
+        pipeline: string;
+    }, {
+        http: string;
+        pipeline: string;
+    }>, z.ZodObject<{
+        event: z.ZodString;
+        pipeline: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        event: string;
+        pipeline: string;
+    }, {
+        event: string;
+        pipeline: string;
+    }>, z.ZodObject<{
+        cron: z.ZodString;
+        pipeline: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        cron: string;
+        pipeline: string;
+    }, {
+        cron: string;
+        pipeline: string;
+    }>]>, "many">;
+    http: z.ZodDefault<z.ZodUnion<[z.ZodNull, z.ZodObject<{
+        port: z.ZodDefault<z.ZodNumber>;
+        host: z.ZodDefault<z.ZodString>;
+        corsOrigin: z.ZodOptional<z.ZodString>;
+        maxBodyBytes: z.ZodDefault<z.ZodNumber>;
+        trustProxy: z.ZodDefault<z.ZodBoolean>;
+        allow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        healthPath: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        inlineTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        timeouts: z.ZodDefault<z.ZodObject<{
+            requestMs: z.ZodDefault<z.ZodNumber>;
+            headersMs: z.ZodDefault<z.ZodNumber>;
+            keepAliveMs: z.ZodDefault<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            requestMs: number;
+            headersMs: number;
+            keepAliveMs: number;
+        }, {
+            requestMs?: number | undefined;
+            headersMs?: number | undefined;
+            keepAliveMs?: number | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        port: number;
+        host: string;
+        maxBodyBytes: number;
+        trustProxy: boolean;
+        allow: string[];
+        healthPath: string | null;
+        inlineTypes: string[];
+        timeouts: {
+            requestMs: number;
+            headersMs: number;
+            keepAliveMs: number;
+        };
+        corsOrigin?: string | undefined;
+    }, {
+        port?: number | undefined;
+        host?: string | undefined;
+        corsOrigin?: string | undefined;
+        maxBodyBytes?: number | undefined;
+        trustProxy?: boolean | undefined;
+        allow?: string[] | undefined;
+        healthPath?: string | null | undefined;
+        inlineTypes?: string[] | undefined;
+        timeouts?: {
+            requestMs?: number | undefined;
+            headersMs?: number | undefined;
+            keepAliveMs?: number | undefined;
+        } | undefined;
+    }>]>>;
+    pipelinesDir: z.ZodDefault<z.ZodString>;
+    shutdownTimeoutMs: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    http: {
+        port: number;
+        host: string;
+        maxBodyBytes: number;
+        trustProxy: boolean;
+        allow: string[];
+        healthPath: string | null;
+        inlineTypes: string[];
+        timeouts: {
+            requestMs: number;
+            headersMs: number;
+            keepAliveMs: number;
+        };
+        corsOrigin?: string | undefined;
+    } | null;
+    modules: {
+        use: string;
+        config?: unknown;
+    }[];
+    triggers: ({
+        http: string;
+        pipeline: string;
+    } | {
+        event: string;
+        pipeline: string;
+    } | {
+        cron: string;
+        pipeline: string;
+    })[];
+    pipelinesDir: string;
+    shutdownTimeoutMs: number;
+}, {
+    modules: {
+        use: string;
+        config?: unknown;
+    }[];
+    triggers: ({
+        http: string;
+        pipeline: string;
+    } | {
+        event: string;
+        pipeline: string;
+    } | {
+        cron: string;
+        pipeline: string;
+    })[];
+    http?: {
+        port?: number | undefined;
+        host?: string | undefined;
+        corsOrigin?: string | undefined;
+        maxBodyBytes?: number | undefined;
+        trustProxy?: boolean | undefined;
+        allow?: string[] | undefined;
+        healthPath?: string | null | undefined;
+        inlineTypes?: string[] | undefined;
+        timeouts?: {
+            requestMs?: number | undefined;
+            headersMs?: number | undefined;
+            keepAliveMs?: number | undefined;
+        } | undefined;
+    } | null | undefined;
+    pipelinesDir?: string | undefined;
+    shutdownTimeoutMs?: number | undefined;
+}>;
+export type KestrelConfig = z.output<typeof configSchema>;
+export type KestrelConfigInput = z.input<typeof configSchema>;
+export type TriggerConfig = KestrelConfig["triggers"][number];
+export declare function defineConfig(config: KestrelConfigInput): KestrelConfigInput;

package/dist/defineConfig.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+const triggerSchema = z.union([
+    z.object({ http: z.string().regex(/^(GET|POST|PUT|PATCH|DELETE) \/\S*$/, "expected e.g. \"GET /pages/:id\""), pipeline: z.string().min(1) }).strict(),
+    z.object({ event: z.string().min(1), pipeline: z.string().min(1) }).strict(),
+    z.object({ cron: z.string().min(1), pipeline: z.string().min(1) }).strict(),
+]);
+export const configSchema = z
+    .object({
+    modules: z.array(z.object({ use: z.string().min(1), config: z.unknown().optional() }).strict()),
+    triggers: z.array(triggerSchema),
+    http: z
+        .union([
+        z.null(),
+        z
+            .object({
+            port: z.number().int().min(0).max(65535).default(3000),
+            host: z.string().default("127.0.0.1"),
+            corsOrigin: z.string().min(1).optional(),
+            maxBodyBytes: z.number().int().positive().default(10 * 1024 * 1024),
+            trustProxy: z.boolean().default(false),
+            allow: z.array(z.string().min(1)).default([]),
+            healthPath: z.string().regex(/^\/\S*$/).nullable().default("/health"),
+            inlineTypes: z.array(z.string().min(1)).default([]),
+            timeouts: z
+                .object({
+                requestMs: z.number().int().nonnegative().default(30_000),
+                headersMs: z.number().int().nonnegative().default(10_000),
+                keepAliveMs: z.number().int().nonnegative().default(5_000),
+            })
+                .strict()
+                .default({}),
+        })
+            .strict(),
+    ])
+        .default({}),
+    pipelinesDir: z.string().default("./pipelines"),
+    shutdownTimeoutMs: z.number().int().nonnegative().default(30_000),
+})
+    .strict();
+export function defineConfig(config) {
+    return config;
+}

package/dist/defineContract.d.ts

@@ -0,0 +1,12 @@
+export interface Contract<T> {
+    readonly name: string;
+    readonly methods: readonly string[];
+    readonly instance?: T;
+}
+type MethodKeys<T> = {
+    [K in keyof T]-?: T[K] extends Function ? K : never;
+}[keyof T] & string;
+type CompleteMethodList<T, M extends readonly MethodKeys<T>[]> = [MethodKeys<T>] extends [M[number]] ? M : never;
+export declare function defineContract<T>(): <const M extends readonly MethodKeys<T>[]>(name: string, methods: CompleteMethodList<T, M>) => Contract<T>;
+export declare function missingMethods<T>(contract: Contract<T>, instance: unknown): string[];
+export {};

package/dist/defineContract.js

@@ -0,0 +1,16 @@
+// Curried so M is inferred fresh at the second call, independent of the CompleteMethodList check on its own parameter.
+export function defineContract() {
+    return (name, methods) => {
+        if (!/^[a-z][a-z0-9-]*@[1-9][0-9]*$/.test(name))
+            throw new Error(`defineContract: name "${name}" must look like "<capability>@<major>"`);
+        if (methods.length === 0)
+            throw new Error(`defineContract: contract "${name}" declares no methods`);
+        return { name, methods };
+    };
+}
+export function missingMethods(contract, instance) {
+    if (instance === null || (typeof instance !== "object" && typeof instance !== "function"))
+        return [...contract.methods];
+    const obj = instance;
+    return contract.methods.filter((m) => typeof obj[m] !== "function");
+}

package/dist/defineModule.d.ts

@@ -0,0 +1,75 @@
+import type { ZodTypeAny, output } from "zod";
+import type { StepFactory, StepMap } from "./context.ts";
+import type { Contract } from "./defineContract.ts";
+import type { Logger } from "./logger.ts";
+import type { Runner } from "./runner.ts";
+export interface Deps {
+    get<T>(contract: Contract<T>): T;
+    find<T>(contract: Contract<T>): T | undefined;
+    logger: Logger;
+    root: string;
+}
+export type JsonSchema = Record<string, unknown>;
+/** A context key optionally followed by dotted sub-keys; a trailing "?" marks a conditional write. */
+export type ContextPath = string;
+export interface StepDescription {
+    summary: string;
+    reads: readonly ContextPath[];
+    writes: readonly ContextPath[];
+    input?: JsonSchema;
+    output?: JsonSchema;
+    /** Merges into the currently active output schema (properties + required union) instead of replacing it; becomes the output if there was none yet. */
+    extendsOutput?: JsonSchema;
+    /** Like extendsOutput, but merges into `properties.items.items` of the active output when it is a list result; falls back to a root merge otherwise. */
+    extendsItems?: JsonSchema;
+    query?: Record<string, JsonSchema>;
+    errors?: Record<number, string>;
+    security?: "required" | "optional";
+    multipart?: boolean;
+    binary?: boolean;
+}
+type DescriptionOf<F> = F extends StepFactory ? (arg: string) => StepDescription : StepDescription;
+export type StepDescriptions<T extends StepMap = StepMap> = {
+    [K in keyof T & string]: DescriptionOf<T[K]>;
+};
+export interface EventEntry {
+    event: string;
+    pipeline: string;
+}
+/** `event` subscribes the module's own bus to the configured entries and returns the stop function the core calls on `stop()`. */
+export interface ModuleTriggers<P> {
+    event?(instance: P, entries: readonly EventEntry[], run: Runner, logger: Logger): () => void;
+}
+export interface ModuleDefinition<N extends string = string, T extends StepMap = StepMap> {
+    name: N;
+    provides: readonly Contract<unknown>[];
+    requires: readonly Contract<unknown>[];
+    optional?: readonly Contract<unknown>[];
+    configSchema: ZodTypeAny;
+    setup(config: unknown, deps: Deps): Promise<unknown>;
+    steps?(instance: unknown): T;
+    describe?(instance: unknown): StepDescriptions<T>;
+    triggers?: ModuleTriggers<unknown>;
+    teardown?(instance: unknown): void | Promise<void>;
+}
+type WithSteps<P, T extends StepMap> = {
+    steps(instance: P): T;
+    describe(instance: P): StepDescriptions<T>;
+};
+type WithoutSteps = {
+    steps?: never;
+    describe?: never;
+};
+export type ModuleInput<N extends string, S extends ZodTypeAny, P, T extends StepMap> = {
+    name: N;
+    provides: readonly Contract<unknown>[];
+    requires: readonly Contract<unknown>[];
+    optional?: readonly Contract<unknown>[];
+    configSchema: S;
+    setup(config: output<S>, deps: Deps): Promise<P>;
+    triggers?: ModuleTriggers<P>;
+    teardown?(instance: P): void | Promise<void>;
+} & (WithSteps<P, T> | WithoutSteps);
+export declare function defineModule<const N extends string, S extends ZodTypeAny, P, T extends StepMap = Record<never, never>>(def: ModuleInput<N, S, P, T>): ModuleDefinition<N, T>;
+export declare function stepPrefix(moduleName: string): string;
+export {};

package/dist/defineModule.js

@@ -0,0 +1,9 @@
+export function defineModule(def) {
+    if (!/^[a-z0-9-]+\/[a-z0-9-]+$/.test(def.name)) {
+        throw new Error(`defineModule: name "${def.name}" must look like "<module>/<submodule>"`);
+    }
+    return def;
+}
+export function stepPrefix(moduleName) {
+    return moduleName.split("/")[0] ?? moduleName;
+}

package/dist/definePipeline.d.ts

@@ -0,0 +1,7 @@
+export interface PipelineDefinition<S extends string = string> {
+    name: string;
+    steps: readonly S[];
+}
+export declare function definePipeline<S extends string = string>(def: PipelineDefinition<S>): PipelineDefinition<S>;
+/** Binds `definePipeline` to a catalogue so pipeline files need no generic argument. */
+export declare function pipelineDefiner<S extends string>(): (def: PipelineDefinition<S>) => PipelineDefinition<S>;

package/dist/definePipeline.js

@@ -0,0 +1,11 @@
+export function definePipeline(def) {
+    if (def.name.trim() === "")
+        throw new Error("definePipeline: name must not be empty");
+    if (def.steps.length === 0)
+        throw new Error(`definePipeline: pipeline "${def.name}" has no steps`);
+    return def;
+}
+/** Binds `definePipeline` to a catalogue so pipeline files need no generic argument. */
+export function pipelineDefiner() {
+    return definePipeline;
+}

package/dist/errors.d.ts

@@ -0,0 +1,26 @@
+export declare class KestrelBootError extends Error {
+    readonly module: string;
+    readonly reason: string;
+    constructor(module: string, reason: string);
+}
+export type CoreCode = "VALIDATION" | "NOT_FOUND" | "CONFLICT" | "FORBIDDEN" | "UNAUTHENTICATED" | "RATE_LIMITED" | "DANGLING_REF" | "PAYLOAD_TOO_LARGE" | "UNSUPPORTED" | "TRANSIENT" | "INTERNAL";
+export interface KestrelError<C extends string = string> {
+    readonly code: C;
+    readonly status: number;
+    readonly message: string;
+    readonly retryable: boolean;
+    readonly details?: Record<string, unknown>;
+    readonly cause?: unknown;
+}
+/** The one place a core code becomes an HTTP status. Nothing else maps codes to numbers. */
+export declare const STATUS_OF: Readonly<Record<CoreCode, number>>;
+export interface FailureOptions {
+    details?: Record<string, unknown>;
+    cause?: unknown;
+}
+export declare function failure<C extends CoreCode>(code: C, message: string, options?: FailureOptions): KestrelError<C>;
+/** For codes a contract declares itself; `status` is fixed by the contract file, never at a call site. */
+export declare function customFailure<C extends string>(code: C, status: number, message: string, options?: FailureOptions & {
+    retryable?: boolean;
+}): KestrelError<C>;
+export declare function isKestrelError(value: unknown): value is KestrelError;

package/dist/errors.js

@@ -0,0 +1,48 @@
+export class KestrelBootError extends Error {
+    module;
+    reason;
+    constructor(module, reason) {
+        super(`[${module}] ${reason}`);
+        this.name = "KestrelBootError";
+        this.module = module;
+        this.reason = reason;
+    }
+}
+/** The one place a core code becomes an HTTP status. Nothing else maps codes to numbers. */
+export const STATUS_OF = {
+    VALIDATION: 400,
+    DANGLING_REF: 400,
+    UNAUTHENTICATED: 401,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    CONFLICT: 409,
+    PAYLOAD_TOO_LARGE: 413,
+    UNSUPPORTED: 415,
+    RATE_LIMITED: 429,
+    INTERNAL: 500,
+    TRANSIENT: 503,
+};
+const RETRYABLE = new Set(["TRANSIENT", "RATE_LIMITED"]);
+export function failure(code, message, options = {}) {
+    const error = { code, status: STATUS_OF[code], message, retryable: RETRYABLE.has(code) };
+    if (options.details !== undefined)
+        error.details = options.details;
+    if (options.cause !== undefined)
+        error.cause = options.cause;
+    return error;
+}
+/** For codes a contract declares itself; `status` is fixed by the contract file, never at a call site. */
+export function customFailure(code, status, message, options = {}) {
+    const error = { code, status, message, retryable: options.retryable ?? false };
+    if (options.details !== undefined)
+        error.details = options.details;
+    if (options.cause !== undefined)
+        error.cause = options.cause;
+    return error;
+}
+export function isKestrelError(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const error = value;
+    return typeof error.code === "string" && typeof error.status === "number" && typeof error.message === "string" && typeof error.retryable === "boolean";
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { boot, type Kestrel, type BootInput, type Triggers } from "./boot.ts";
+export { matchRoute, routePattern, parseRequestBody, parseQuery, buildResponse, responseForRun, errorResponse, clientIp, BodyTooLarge, type Route, type ParsedBody, type HttpResponse, type HttpTimeouts, type ResponseMeta } from "./triggers/http.ts";
+export { defineConfig, type KestrelConfig, type KestrelConfigInput } from "./defineConfig.ts";
+export { defineContract, type Contract } from "./defineContract.ts";
+export { defineModule, type ModuleDefinition, type ModuleInput, type ModuleTriggers, type Deps, type EventEntry, type ContextPath, type JsonSchema, type StepDescription, type StepDescriptions } from "./defineModule.ts";
+export type { ResolvedPipeline } from "./runner.ts";
+export type { ResolvedStep } from "./registry.ts";
+export { definePipeline, pipelineDefiner, type PipelineDefinition } from "./definePipeline.ts";
+export type { StepsOf, StepCatalogue } from "./catalogue.ts";
+export { createContext, binaryResult, isBinaryResult, first, requestIdOf, stepFactory, isStepFactory, type BinaryResult, type Context, type ContextInput, type Step, type StepFactory, type StepMap, type StepResult, type Trigger, type UploadedFile } from "./context.ts";
+export { KestrelBootError, STATUS_OF, failure, customFailure, isKestrelError, type CoreCode, type FailureOptions, type KestrelError } from "./errors.ts";
+export { ok, err, isOk, isErr, match, unwrapOr, type Ok, type Err, type Result } from "./result.ts";
+export { boundaryCast, type Boundary } from "./cast.ts";
+export { loadConfig, loadModules, loadPipelines } from "./load.ts";
+export { consoleLogger, silentLogger, logWarn, type Logger, type StepLog } from "./logger.ts";
+export type { RunResult, Runner, RunTracker, RunOptions } from "./runner.ts";
+export { checkDataflow } from "./dataflow.ts";
+export { validateSchema, type SchemaProblem } from "./schema.ts";
+export type { StopOptions, StopResult } from "./boot.ts";

package/dist/index.js

@@ -0,0 +1,14 @@
+export { boot } from "./boot.js";
+export { matchRoute, routePattern, parseRequestBody, parseQuery, buildResponse, responseForRun, errorResponse, clientIp, BodyTooLarge } from "./triggers/http.js";
+export { defineConfig } from "./defineConfig.js";
+export { defineContract } from "./defineContract.js";
+export { defineModule } from "./defineModule.js";
+export { definePipeline, pipelineDefiner } from "./definePipeline.js";
+export { createContext, binaryResult, isBinaryResult, first, requestIdOf, stepFactory, isStepFactory } from "./context.js";
+export { KestrelBootError, STATUS_OF, failure, customFailure, isKestrelError } from "./errors.js";
+export { ok, err, isOk, isErr, match, unwrapOr } from "./result.js";
+export { boundaryCast } from "./cast.js";
+export { loadConfig, loadModules, loadPipelines } from "./load.js";
+export { consoleLogger, silentLogger, logWarn } from "./logger.js";
+export { checkDataflow } from "./dataflow.js";
+export { validateSchema } from "./schema.js";

package/dist/load.d.ts

@@ -0,0 +1,7 @@
+import type { KestrelConfigInput } from "./defineConfig.ts";
+import type { ModuleDefinition } from "./defineModule.ts";
+import type { PipelineDefinition } from "./definePipeline.ts";
+export declare function loadConfig(file: string): Promise<KestrelConfigInput>;
+export declare function resolveModuleFile(root: string, use: string): string;
+export declare function loadModules(root: string, config: KestrelConfigInput): Promise<ModuleDefinition[]>;
+export declare function loadPipelines(root: string, dir: string): Promise<PipelineDefinition[]>;