@swirls/looms 0.0.2 → 0.2.0

package/dist/evaluator/module.d.ts

@@ -0,0 +1,606 @@
+import type { EvaluatorDefinition } from './definitions';
+import { EvaluatorTag, type StubEvaluatorPolicy } from './evaluator';
+import type { EvaluatorAdapter } from './types';
+export interface EvaluatorModuleOptions {
+    readonly definitions?: readonly EvaluatorDefinition[];
+    /** Model adapter used for every evaluation. Defaults to a deterministic stub. */
+    readonly evaluator?: EvaluatorAdapter;
+    readonly evaluatorPolicy?: StubEvaluatorPolicy;
+}
+export declare function evaluator(options?: EvaluatorModuleOptions): import("@swirls/looms/core").RuntimeModule<"evaluator", 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;
+        }>>;
+    }>;
+}>, {
+    evaluate: import("@swirls/looms/core").EffectDefinition<{
+        readonly evaluationId: string;
+        readonly definitionName?: string | undefined;
+        readonly input?: import("effect/Schema").Json | undefined;
+    }, import("./definitions-store").EvaluatorDefinitionsTag | EvaluatorTag, (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "evaluator.evaluated";
+        readonly payload: {
+            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;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "evaluator.requested";
+        readonly payload: {
+            readonly evaluationId: string;
+            readonly definitionName?: string | undefined;
+            readonly state: string;
+            readonly model?: string | undefined;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.ambiguous";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly error: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.attempt.started";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.cancel.requested";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly deadlineAt: number | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.cancelled";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.completed";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.dispatched";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly deadlineAt: number | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.failed";
+        readonly payload: {
+            readonly effectId: string;
+            readonly error: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.heartbeat";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly heartbeatAt: number;
+            readonly deadlineAt: number | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.queued";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly deadlineAt: number | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.retry.scheduled";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly nextAttemptAt: number;
+            readonly error: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.timed_out";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly timeout: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.effect.worker.started";
+        readonly payload: {
+            readonly effectId: string;
+            readonly attempt: number;
+            readonly deadlineAt: number | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.run.cancelled";
+        readonly payload: {
+            readonly reason?: string | undefined;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.run.completed";
+        readonly payload: {
+            readonly output: import("effect/Schema").Json;
+            readonly error: string | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.run.started";
+        readonly payload: {
+            readonly rootThreadId?: string | undefined;
+            readonly kind: string;
+            readonly definitionName: string;
+            readonly definitionVersion: string;
+            readonly input: import("effect/Schema").Json;
+            readonly requestedThreadId?: string | null | undefined;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.signal.received";
+        readonly payload: {
+            readonly signalType: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.snapshot.taken";
+        readonly payload: {
+            readonly seq: number;
+            readonly stateHash: string;
+            readonly state?: import("effect/Schema").Json | undefined;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.thread.cancel.requested";
+        readonly payload: {
+            readonly threadId: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.thread.cancelled";
+        readonly payload: {
+            readonly threadId: string;
+            readonly reason?: string | undefined;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.thread.completed";
+        readonly payload: {
+            readonly threadId: string;
+            readonly output: import("effect/Schema").Json;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.thread.failed";
+        readonly payload: {
+            readonly threadId: string;
+            readonly error: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.thread.started";
+        readonly payload: {
+            readonly threadId: string;
+            readonly kind: string;
+            readonly definitionName: string;
+            readonly definitionVersion: string;
+            readonly input: import("effect/Schema").Json;
+            readonly parentThreadId: string | null;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.timer.fired";
+        readonly payload: {
+            readonly timerId: string;
+            readonly waitId: string;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.timer.set";
+        readonly payload: {
+            readonly timerId: string;
+            readonly waitId: string;
+            readonly wakeAt: number;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.wait.registered";
+        readonly payload: {
+            readonly waitId: string;
+            readonly threadId?: string | undefined;
+            readonly on: {
+                readonly type: string | readonly string[];
+                readonly match?: import("effect/Schema").Json | undefined;
+            } | {
+                readonly timerAt: number;
+            };
+            readonly tag?: import("effect/Schema").Json | undefined;
+        };
+    }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+        readonly type: "runtime.wait.satisfied";
+        readonly payload: {
+            readonly waitId: string;
+            readonly tag?: import("effect/Schema").Json | undefined;
+            readonly event: {
+                readonly id: string;
+                readonly type: string;
+                readonly payload: import("effect/Schema").Json;
+            };
+        };
+    })>;
+}, {
+    evaluator: import("@swirls/looms/core").ThreadDefinition<{
+        readonly definitionName?: string | undefined;
+        readonly input: import("effect/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;
+    }>;
+}, {
+    evaluations: import("@swirls/looms/core").ProjectionDefinition<{
+        readonly items: {
+            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;
+        }[];
+    }>;
+}, import("effect/Context").Service.Any> & {
+    readonly effects: {
+        evaluate: import("@swirls/looms/core").EffectDefinition<{
+            readonly evaluationId: string;
+            readonly definitionName?: string | undefined;
+            readonly input?: import("effect/Schema").Json | undefined;
+        }, import("./definitions-store").EvaluatorDefinitionsTag | EvaluatorTag, (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "evaluator.evaluated";
+            readonly payload: {
+                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;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "evaluator.requested";
+            readonly payload: {
+                readonly evaluationId: string;
+                readonly definitionName?: string | undefined;
+                readonly state: string;
+                readonly model?: string | undefined;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.ambiguous";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly error: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.attempt.started";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.cancel.requested";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly deadlineAt: number | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.cancelled";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.completed";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.dispatched";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly deadlineAt: number | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.failed";
+            readonly payload: {
+                readonly effectId: string;
+                readonly error: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.heartbeat";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly heartbeatAt: number;
+                readonly deadlineAt: number | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.queued";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly deadlineAt: number | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.retry.scheduled";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly nextAttemptAt: number;
+                readonly error: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.timed_out";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly timeout: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.effect.worker.started";
+            readonly payload: {
+                readonly effectId: string;
+                readonly attempt: number;
+                readonly deadlineAt: number | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.run.cancelled";
+            readonly payload: {
+                readonly reason?: string | undefined;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.run.completed";
+            readonly payload: {
+                readonly output: import("effect/Schema").Json;
+                readonly error: string | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.run.started";
+            readonly payload: {
+                readonly rootThreadId?: string | undefined;
+                readonly kind: string;
+                readonly definitionName: string;
+                readonly definitionVersion: string;
+                readonly input: import("effect/Schema").Json;
+                readonly requestedThreadId?: string | null | undefined;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.signal.received";
+            readonly payload: {
+                readonly signalType: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.snapshot.taken";
+            readonly payload: {
+                readonly seq: number;
+                readonly stateHash: string;
+                readonly state?: import("effect/Schema").Json | undefined;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.thread.cancel.requested";
+            readonly payload: {
+                readonly threadId: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.thread.cancelled";
+            readonly payload: {
+                readonly threadId: string;
+                readonly reason?: string | undefined;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.thread.completed";
+            readonly payload: {
+                readonly threadId: string;
+                readonly output: import("effect/Schema").Json;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.thread.failed";
+            readonly payload: {
+                readonly threadId: string;
+                readonly error: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.thread.started";
+            readonly payload: {
+                readonly threadId: string;
+                readonly kind: string;
+                readonly definitionName: string;
+                readonly definitionVersion: string;
+                readonly input: import("effect/Schema").Json;
+                readonly parentThreadId: string | null;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.timer.fired";
+            readonly payload: {
+                readonly timerId: string;
+                readonly waitId: string;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.timer.set";
+            readonly payload: {
+                readonly timerId: string;
+                readonly waitId: string;
+                readonly wakeAt: number;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.wait.registered";
+            readonly payload: {
+                readonly waitId: string;
+                readonly threadId?: string | undefined;
+                readonly on: {
+                    readonly type: string | readonly string[];
+                    readonly match?: import("effect/Schema").Json | undefined;
+                } | {
+                    readonly timerAt: number;
+                };
+                readonly tag?: import("effect/Schema").Json | undefined;
+            };
+        }) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+            readonly type: "runtime.wait.satisfied";
+            readonly payload: {
+                readonly waitId: string;
+                readonly tag?: import("effect/Schema").Json | undefined;
+                readonly event: {
+                    readonly id: string;
+                    readonly type: string;
+                    readonly payload: import("effect/Schema").Json;
+                };
+            };
+        })>;
+    };
+    readonly threads: {
+        evaluator: import("@swirls/looms/core").ThreadDefinition<{
+            readonly definitionName?: string | undefined;
+            readonly input: import("effect/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;
+        }>;
+    };
+    readonly projections: {
+        evaluations: import("@swirls/looms/core").ProjectionDefinition<{
+            readonly items: {
+                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;
+            }[];
+        }>;
+    };
+};

package/dist/evaluator/module.js

@@ -0,0 +1,25 @@
+import { Layer } from 'effect';
+import { defineModule } from '@swirls/looms/core';
+import { EvaluatorDefinitionsLive } from './definitions-store.js';
+import { evaluateEffect } from './effects.js';
+import { evaluatorFromAdapter, EvaluatorTag, StubEvaluatorLive, } from './evaluator.js';
+import { evaluations } from './projections.js';
+import { evaluatorModule } from './scope.js';
+import { evaluatorThread } from './threads.js';
+export function evaluator(options = {}) {
+    const definitions = options.definitions ?? [];
+    const evaluatorLayer = options.evaluator
+        ? Layer.succeed(EvaluatorTag, evaluatorFromAdapter(options.evaluator))
+        : StubEvaluatorLive(options.evaluatorPolicy);
+    return defineModule(evaluatorModule, () => ({
+        definitions,
+        threads: { evaluator: evaluatorThread },
+        effects: {
+            evaluate: evaluateEffect,
+        },
+        projections: {
+            evaluations,
+        },
+        services: () => Layer.merge(evaluatorLayer, EvaluatorDefinitionsLive(definitions)),
+    }));
+}

package/dist/evaluator/projections.d.ts

@@ -0,0 +1,50 @@
+import { Schema } from 'effect';
+export declare const EvaluationsSchema: Schema.Struct<{
+    readonly items: Schema.mutable<Schema.$Array<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;
+        }>>;
+    }>>>;
+}>;
+export type EvaluationsState = Schema.Schema.Type<typeof EvaluationsSchema>;
+export declare const evaluations: import("@swirls/looms/core").ProjectionDefinition<{
+    readonly items: {
+        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;
+    }[];
+}>;