@swirls/looms 0.0.2 → 0.2.0

package/dist/evaluator/projections.js

@@ -0,0 +1,20 @@
+import { Schema } from 'effect';
+import { EvaluatorEvaluatedPayloadSchema } from './events.js';
+import { evaluatorModule } from './scope.js';
+export const EvaluationsSchema = Schema.Struct({
+    items: Schema.mutable(Schema.Array(EvaluatorEvaluatedPayloadSchema)),
+});
+export const evaluations = evaluatorModule.projection({
+    name: 'evaluations',
+    shape: EvaluationsSchema,
+    initialState: { items: [] },
+    reduce(state, event) {
+        if (event.type !== 'evaluator.evaluated') {
+            return state;
+        }
+        const next = event.payload;
+        return {
+            items: [...state.items.filter((item) => item.evaluationId !== next.evaluationId), next],
+        };
+    },
+});

package/dist/evaluator/scope.d.ts

@@ -0,0 +1,59 @@
+import { type EventOf } from '@swirls/looms/core';
+export declare const evaluatorModule: import("@swirls/looms/core").ModuleScope<"evaluator", import("@swirls/looms/core").ScopeUniverse<import("@swirls/looms/core").EventCatalog<"evaluator", {
+    requested: import("effect/Schema").Struct<{
+        readonly evaluationId: import("effect/Schema").String;
+        readonly definitionName: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly state: import("effect/Schema").String;
+        readonly model: import("effect/Schema").optional<import("effect/Schema").String>;
+    }>;
+    evaluated: import("effect/Schema").Struct<{
+        readonly evaluationId: import("effect/Schema").String;
+        readonly definitionName: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly answers: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"boolean">;
+            readonly value: import("effect/Schema").Boolean;
+            readonly probability: import("effect/Schema").Finite;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"choice">;
+            readonly value: import("effect/Schema").String;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"score">;
+            readonly value: import("effect/Schema").Finite;
+        }>]>>;
+        readonly route: import("effect/Schema").String;
+        readonly reason: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"model">, import("effect/Schema").Literal<"uncertain">, import("effect/Schema").Literal<"skipped">, import("effect/Schema").Literal<"unavailable">]>;
+        readonly usage: import("effect/Schema").optional<import("effect/Schema").Struct<{
+            readonly input: import("effect/Schema").Finite;
+            readonly output: import("effect/Schema").Finite;
+        }>>;
+    }>;
+}>, undefined>, import("@swirls/looms/core").EventCatalog<"evaluator", {
+    requested: import("effect/Schema").Struct<{
+        readonly evaluationId: import("effect/Schema").String;
+        readonly definitionName: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly state: import("effect/Schema").String;
+        readonly model: import("effect/Schema").optional<import("effect/Schema").String>;
+    }>;
+    evaluated: import("effect/Schema").Struct<{
+        readonly evaluationId: import("effect/Schema").String;
+        readonly definitionName: import("effect/Schema").optional<import("effect/Schema").String>;
+        readonly answers: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"boolean">;
+            readonly value: import("effect/Schema").Boolean;
+            readonly probability: import("effect/Schema").Finite;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"choice">;
+            readonly value: import("effect/Schema").String;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"score">;
+            readonly value: import("effect/Schema").Finite;
+        }>]>>;
+        readonly route: import("effect/Schema").String;
+        readonly reason: import("effect/Schema").Union<readonly [import("effect/Schema").Literal<"model">, import("effect/Schema").Literal<"uncertain">, import("effect/Schema").Literal<"skipped">, import("effect/Schema").Literal<"unavailable">]>;
+        readonly usage: import("effect/Schema").optional<import("effect/Schema").Struct<{
+            readonly input: import("effect/Schema").Finite;
+            readonly output: import("effect/Schema").Finite;
+        }>>;
+    }>;
+}>, undefined>;
+export type EvaluatorEvent = EventOf<typeof evaluatorModule>;

package/dist/evaluator/scope.js

@@ -0,0 +1,7 @@
+import { createModuleScope } from '@swirls/looms/core';
+import { evaluatorCatalog } from './events.js';
+export const evaluatorModule = createModuleScope({
+    namespace: 'evaluator',
+    protocolVersion: '1.0.0',
+    events: evaluatorCatalog,
+});

package/dist/evaluator/signals.d.ts

@@ -0,0 +1,3 @@
+import { type JsonValue, type RuntimeEffect } from '@swirls/looms/core';
+import type { EvaluatorDefinition } from './definitions';
+export declare function evaluate(definition: EvaluatorDefinition, input: JsonValue): RuntimeEffect[];

package/dist/evaluator/signals.js

@@ -0,0 +1,17 @@
+import { createWaitId, invoke, wait } from '@swirls/looms/core';
+import { evaluateEffect } from './effects.js';
+export function evaluate(definition, input) {
+    const evaluationId = createWaitId('evaluator');
+    return [
+        invoke(evaluateEffect, {
+            evaluationId,
+            definitionName: definition.name,
+            input,
+        }, `evaluate_${evaluationId}`),
+        wait({
+            waitId: createWaitId(evaluationId, 'result'),
+            on: { type: 'evaluator.evaluated', match: { evaluationId } },
+            tag: { evaluationId },
+        }),
+    ];
+}

package/dist/evaluator/threads.d.ts

@@ -0,0 +1,62 @@
+import { Schema } from 'effect';
+export declare const EvaluatorThreadStateSchema: Schema.Struct<{
+    readonly definitionName: Schema.optional<Schema.String>;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly evaluationId: Schema.String;
+    readonly dispatched: Schema.Boolean;
+    readonly status: Schema.Union<readonly [Schema.Literal<"pending">, Schema.Literal<"completed">, Schema.Literal<"failed">]>;
+    readonly output: Schema.NullOr<Schema.Struct<{
+        readonly evaluationId: Schema.String;
+        readonly definitionName: Schema.optional<Schema.String>;
+        readonly answers: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"boolean">;
+            readonly value: Schema.Boolean;
+            readonly probability: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"choice">;
+            readonly value: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"score">;
+            readonly value: Schema.Finite;
+        }>]>>;
+        readonly route: Schema.String;
+        readonly reason: Schema.Union<readonly [Schema.Literal<"model">, Schema.Literal<"uncertain">, Schema.Literal<"skipped">, Schema.Literal<"unavailable">]>;
+        readonly usage: Schema.optional<Schema.Struct<{
+            readonly input: Schema.Finite;
+            readonly output: Schema.Finite;
+        }>>;
+    }>>;
+    readonly error: Schema.NullOr<Schema.String>;
+}>;
+export type EvaluatorThreadState = Schema.Schema.Type<typeof EvaluatorThreadStateSchema>;
+export declare const evaluatorThread: import("@swirls/looms/core").ThreadDefinition<{
+    readonly definitionName?: string | undefined;
+    readonly input: Schema.Json;
+    readonly evaluationId: string;
+    readonly dispatched: boolean;
+    readonly status: "completed" | "failed" | "pending";
+    readonly output: {
+        readonly evaluationId: string;
+        readonly definitionName?: string | undefined;
+        readonly answers: {
+            readonly [x: string]: {
+                readonly type: "boolean";
+                readonly value: boolean;
+                readonly probability: number;
+            } | {
+                readonly type: "choice";
+                readonly value: string;
+            } | {
+                readonly type: "score";
+                readonly value: number;
+            };
+        };
+        readonly route: string;
+        readonly reason: "model" | "skipped" | "unavailable" | "uncertain";
+        readonly usage?: {
+            readonly input: number;
+            readonly output: number;
+        } | undefined;
+    } | null;
+    readonly error: string | null;
+}>;

package/dist/evaluator/threads.js

@@ -0,0 +1,117 @@
+import { Option, Predicate, Schema } from 'effect';
+import { asJson, complete, createWaitId, fail, invoke, wait, } from '@swirls/looms/core';
+import { evaluateEffect } from './effects.js';
+import { EvaluatorEvaluatedPayloadSchema } from './events.js';
+import { evaluatorModule } from './scope.js';
+export const EvaluatorThreadStateSchema = Schema.Struct({
+    definitionName: Schema.optional(Schema.String),
+    input: Schema.Json,
+    evaluationId: Schema.String,
+    dispatched: Schema.Boolean,
+    status: Schema.Union([
+        Schema.Literal('pending'),
+        Schema.Literal('completed'),
+        Schema.Literal('failed'),
+    ]),
+    output: Schema.NullOr(EvaluatorEvaluatedPayloadSchema),
+    error: Schema.NullOr(Schema.String),
+});
+const decodeEvaluated = Schema.decodeUnknownOption(EvaluatorEvaluatedPayloadSchema);
+function readEvaluated(payload) {
+    const decoded = decodeEvaluated(payload);
+    return Option.isSome(decoded) ? decoded.value : undefined;
+}
+export const evaluatorThread = evaluatorModule.thread({
+    kind: 'evaluator',
+    shape: EvaluatorThreadStateSchema,
+    initialState: (ctx) => ({
+        definitionName: ctx.definitionName,
+        input: ctx.input,
+        evaluationId: `eval_${ctx.threadId}`,
+        dispatched: false,
+        status: 'pending',
+        output: null,
+        error: null,
+    }),
+    step(state, event, ctx) {
+        if (state.status === 'completed' || state.status === 'failed') {
+            return state;
+        }
+        switch (event.type) {
+            case 'runtime.thread.started': {
+                return {
+                    ...state,
+                    definitionName: event.payload.definitionName || state.definitionName,
+                    input: event.payload.input ?? state.input,
+                    evaluationId: `eval_${ctx.threadId}`,
+                };
+            }
+            case 'evaluator.requested': {
+                if (event.payload.evaluationId !== state.evaluationId) {
+                    return state;
+                }
+                return { ...state, dispatched: true };
+            }
+            case 'evaluator.evaluated': {
+                if (event.payload.evaluationId !== state.evaluationId) {
+                    return state;
+                }
+                return {
+                    ...state,
+                    dispatched: true,
+                    status: 'completed',
+                    output: event.payload,
+                    error: null,
+                };
+            }
+            case 'runtime.effect.failed': {
+                const error = event.payload.error || 'Evaluation failed';
+                return {
+                    ...state,
+                    status: 'failed',
+                    error,
+                };
+            }
+            case 'runtime.wait.satisfied': {
+                const embedded = event.payload.event;
+                if (!Predicate.isObject(embedded) || embedded.type !== 'evaluator.evaluated') {
+                    return state;
+                }
+                const evaluated = readEvaluated(embedded.payload);
+                if (!evaluated || evaluated.evaluationId !== state.evaluationId) {
+                    return state;
+                }
+                return {
+                    ...state,
+                    dispatched: true,
+                    status: 'completed',
+                    output: evaluated,
+                    error: null,
+                };
+            }
+            default:
+                return state;
+        }
+    },
+    effects(state) {
+        if (state.status === 'failed') {
+            return [fail(state.error ?? 'Evaluation failed')];
+        }
+        if (state.status === 'completed') {
+            return [complete(asJson(state.output ?? null))];
+        }
+        const effects = [];
+        if (!state.dispatched) {
+            effects.push(invoke(evaluateEffect, {
+                evaluationId: state.evaluationId,
+                definitionName: state.definitionName,
+                input: state.input,
+            }, `evaluate_${state.evaluationId}`));
+        }
+        effects.push(wait({
+            waitId: createWaitId(state.evaluationId, 'result'),
+            on: { type: 'evaluator.evaluated', match: { evaluationId: state.evaluationId } },
+        }));
+        return effects;
+    },
+});

package/dist/evaluator/types.d.ts

@@ -0,0 +1,125 @@
+import { Schema } from 'effect';
+import type { JsonValue } from '@swirls/looms/core';
+export declare const BooleanQuestionSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"boolean">;
+    readonly instructions: Schema.String;
+}>;
+export type BooleanQuestion = Schema.Schema.Type<typeof BooleanQuestionSchema>;
+export declare const ChoiceQuestionSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"choice">;
+    readonly instructions: Schema.String;
+    readonly criteria: Schema.$Record<Schema.String, Schema.String>;
+}>;
+export type ChoiceQuestion = Schema.Schema.Type<typeof ChoiceQuestionSchema>;
+export declare const ScoreQuestionSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"score">;
+    readonly instructions: Schema.String;
+    readonly criteria: Schema.$Array<Schema.String>;
+}>;
+export type ScoreQuestion = Schema.Schema.Type<typeof ScoreQuestionSchema>;
+export declare const EvaluatorQuestionSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"boolean">;
+    readonly instructions: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"choice">;
+    readonly instructions: Schema.String;
+    readonly criteria: Schema.$Record<Schema.String, Schema.String>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"score">;
+    readonly instructions: Schema.String;
+    readonly criteria: Schema.$Array<Schema.String>;
+}>]>;
+export type EvaluatorQuestion = Schema.Schema.Type<typeof EvaluatorQuestionSchema>;
+export declare const EvaluatorQuestionsSchema: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"boolean">;
+    readonly instructions: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"choice">;
+    readonly instructions: Schema.String;
+    readonly criteria: Schema.$Record<Schema.String, Schema.String>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"score">;
+    readonly instructions: Schema.String;
+    readonly criteria: Schema.$Array<Schema.String>;
+}>]>>;
+export type EvaluatorQuestions = Schema.Schema.Type<typeof EvaluatorQuestionsSchema>;
+export declare const BooleanAnswerSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"boolean">;
+    readonly value: Schema.Boolean;
+    readonly probability: Schema.Finite;
+}>;
+export type BooleanAnswer = Schema.Schema.Type<typeof BooleanAnswerSchema>;
+export declare const ChoiceAnswerSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"choice">;
+    readonly value: Schema.String;
+}>;
+export type ChoiceAnswer = Schema.Schema.Type<typeof ChoiceAnswerSchema>;
+export declare const ScoreAnswerSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"score">;
+    readonly value: Schema.Finite;
+}>;
+export type ScoreAnswer = Schema.Schema.Type<typeof ScoreAnswerSchema>;
+export declare const EvaluatorAnswerSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"boolean">;
+    readonly value: Schema.Boolean;
+    readonly probability: Schema.Finite;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"choice">;
+    readonly value: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"score">;
+    readonly value: Schema.Finite;
+}>]>;
+export type EvaluatorAnswer = Schema.Schema.Type<typeof EvaluatorAnswerSchema>;
+export declare const EvaluatorAnswersSchema: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"boolean">;
+    readonly value: Schema.Boolean;
+    readonly probability: Schema.Finite;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"choice">;
+    readonly value: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"score">;
+    readonly value: Schema.Finite;
+}>]>>;
+export type EvaluatorAnswers = Schema.Schema.Type<typeof EvaluatorAnswersSchema>;
+export declare const EvaluatorRouteSchema: Schema.String;
+export type EvaluatorRoute = Schema.Schema.Type<typeof EvaluatorRouteSchema>;
+export declare const EvaluatorReasonSchema: Schema.Union<readonly [Schema.Literal<"model">, Schema.Literal<"uncertain">, Schema.Literal<"skipped">, Schema.Literal<"unavailable">]>;
+export type EvaluatorReason = Schema.Schema.Type<typeof EvaluatorReasonSchema>;
+export declare const EvaluatorUsageSchema: Schema.Struct<{
+    readonly input: Schema.Finite;
+    readonly output: Schema.Finite;
+}>;
+export type EvaluatorUsage = Schema.Schema.Type<typeof EvaluatorUsageSchema>;
+export interface EvaluatorEvaluateArgs {
+    readonly model?: string;
+    readonly state: string;
+    readonly questions: EvaluatorQuestions;
+    readonly signal?: AbortSignal;
+}
+export interface EvaluatorEvaluateResult {
+    readonly answers: EvaluatorAnswers;
+    readonly usage?: EvaluatorUsage;
+    readonly raw?: unknown;
+}
+export interface EvaluatorAdapter {
+    readonly evaluate: (args: EvaluatorEvaluateArgs) => Promise<EvaluatorEvaluateResult>;
+}
+export interface EvaluatorSkipResult {
+    readonly route: string;
+    readonly reason: 'skipped' | 'unavailable';
+    readonly answers?: EvaluatorAnswers;
+}
+export interface EvaluatorRouteDecision {
+    readonly route: string;
+    readonly reason?: EvaluatorReason;
+}
+export interface ResolvedEvaluatorDecision {
+    readonly route: string;
+    readonly reason: EvaluatorReason;
+}
+export interface EvaluatorRouteArgs {
+    readonly answers: EvaluatorAnswers;
+    readonly input: JsonValue;
+}

package/dist/evaluator/types.js

@@ -0,0 +1,51 @@
+import { Schema } from 'effect';
+export const BooleanQuestionSchema = Schema.Struct({
+    type: Schema.Literal('boolean'),
+    instructions: Schema.String,
+});
+export const ChoiceQuestionSchema = Schema.Struct({
+    type: Schema.Literal('choice'),
+    instructions: Schema.String,
+    criteria: Schema.Record(Schema.String, Schema.String),
+});
+export const ScoreQuestionSchema = Schema.Struct({
+    type: Schema.Literal('score'),
+    instructions: Schema.String,
+    criteria: Schema.Array(Schema.String),
+});
+export const EvaluatorQuestionSchema = Schema.Union([
+    BooleanQuestionSchema,
+    ChoiceQuestionSchema,
+    ScoreQuestionSchema,
+]);
+export const EvaluatorQuestionsSchema = Schema.Record(Schema.String, EvaluatorQuestionSchema);
+export const BooleanAnswerSchema = Schema.Struct({
+    type: Schema.Literal('boolean'),
+    value: Schema.Boolean,
+    probability: Schema.Finite,
+});
+export const ChoiceAnswerSchema = Schema.Struct({
+    type: Schema.Literal('choice'),
+    value: Schema.String,
+});
+export const ScoreAnswerSchema = Schema.Struct({
+    type: Schema.Literal('score'),
+    value: Schema.Finite,
+});
+export const EvaluatorAnswerSchema = Schema.Union([
+    BooleanAnswerSchema,
+    ChoiceAnswerSchema,
+    ScoreAnswerSchema,
+]);
+export const EvaluatorAnswersSchema = Schema.Record(Schema.String, EvaluatorAnswerSchema);
+export const EvaluatorRouteSchema = Schema.String;
+export const EvaluatorReasonSchema = Schema.Union([
+    Schema.Literal('model'),
+    Schema.Literal('uncertain'),
+    Schema.Literal('skipped'),
+    Schema.Literal('unavailable'),
+]);
+export const EvaluatorUsageSchema = Schema.Struct({
+    input: Schema.Finite,
+    output: Schema.Finite,
+});

package/dist/projectors/delivery.d.ts

@@ -0,0 +1,83 @@
+import { Effect } from 'effect';
+import type { EventStore, EventStoreError } from '@swirls/looms/core';
+import { type Projector } from './projector';
+export type ProjectorDeliveryState = 'idle' | 'retrying' | 'dead-letter';
+export interface ProjectorDeliveryStatus {
+    readonly runId: string;
+    readonly projector: string;
+    readonly version: string;
+    readonly cursor: number;
+    readonly state: ProjectorDeliveryState;
+    readonly attempts: number;
+    readonly failedSeq: number | null;
+    readonly nextRetryAt: number | null;
+    readonly lastError: string | null;
+    readonly updatedAt: number;
+}
+declare const ProjectorCursorError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ProjectorCursorError";
+} & Readonly<A>;
+export declare class ProjectorCursorError extends ProjectorCursorError_base<{
+    readonly message: string;
+}> {
+}
+export interface ProjectorCursorStore {
+    get(runId: string, projector: Projector): Effect.Effect<ProjectorDeliveryStatus, ProjectorCursorError>;
+    advance(runId: string, projector: Projector, cursor: number, now: number): Effect.Effect<void, ProjectorCursorError>;
+    fail(runId: string, projector: Projector, failure: {
+        readonly attempts: number;
+        readonly failedSeq: number;
+        readonly nextRetryAt: number | null;
+        readonly error: string;
+        readonly now: number;
+    }): Effect.Effect<void, ProjectorCursorError>;
+    requeue(runId: string, projector: Projector, now: number): Effect.Effect<void, ProjectorCursorError>;
+    list(runId?: string): Effect.Effect<readonly ProjectorDeliveryStatus[], ProjectorCursorError>;
+}
+declare const UnknownProjectorError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "UnknownProjectorError";
+} & Readonly<A>;
+export declare class UnknownProjectorError extends UnknownProjectorError_base<{
+    readonly message: string;
+}> {
+}
+export type ProjectorDeliveryFailure = ProjectorCursorError | EventStoreError;
+export interface ProjectorDeliveryOptions {
+    readonly batchSize?: number;
+    readonly initialRetryMs?: number;
+    readonly maxRetryMs?: number;
+    readonly maxAttempts?: number;
+    readonly now?: () => number;
+    readonly scheduleRetry?: (at: number) => Effect.Effect<void>;
+    readonly observer?: ProjectorObserver;
+}
+export type ProjectorObservation = {
+    readonly type: 'projector.lag' | 'projector.retry' | 'projector.dead-letter';
+    readonly runId: string;
+    readonly projector: string;
+    readonly at: number;
+    readonly cursor: number;
+    readonly lag: number;
+    readonly attempts: number;
+    readonly error?: string;
+};
+export interface ProjectorObserver {
+    observe(event: ProjectorObservation): void | Promise<void>;
+}
+export interface ProjectorOperationalStatus extends ProjectorDeliveryStatus {
+    readonly sourceTail: number;
+    readonly lag: number;
+}
+export interface ProjectorDelivery {
+    deliver(runId: string, options?: {
+        readonly force?: boolean;
+    }): Effect.Effect<void, ProjectorDeliveryFailure>;
+    status(runId?: string): Effect.Effect<readonly ProjectorDeliveryStatus[], ProjectorCursorError>;
+    requeue(runId: string, projectorName: string, version?: string): Effect.Effect<void, ProjectorDeliveryFailure | UnknownProjectorError>;
+    nextRetryAt(runId?: string): Effect.Effect<number | null, ProjectorCursorError>;
+    inspect(runId?: string): Effect.Effect<readonly ProjectorOperationalStatus[], ProjectorDeliveryFailure>;
+    /** Re-register retry deadlines and resume due retryable projector work. */
+    recover(runId?: string): Effect.Effect<number, ProjectorDeliveryFailure>;
+}
+export declare function createProjectorDelivery(source: EventStore, projectors: readonly Projector[], cursors: ProjectorCursorStore, options?: ProjectorDeliveryOptions): ProjectorDelivery;
+export {};