@swirls/looms 0.0.2 → 0.2.0

package/dist/debugger/ui/popover.d.ts

@@ -0,0 +1,7 @@
+import { Popover as PopoverPrimitive } from 'radix-ui';
+import * as React from 'react';
+declare function Popover(props: React.ComponentProps<typeof PopoverPrimitive.Root>): React.JSX.Element;
+declare function PopoverTrigger(props: React.ComponentProps<typeof PopoverPrimitive.Trigger>): React.JSX.Element;
+declare function PopoverAnchor(props: React.ComponentProps<typeof PopoverPrimitive.Anchor>): React.JSX.Element;
+declare function PopoverContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof PopoverPrimitive.Content>): React.JSX.Element;
+export { Popover, PopoverAnchor, PopoverContent, PopoverTrigger };

package/dist/debugger/ui/popover.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Popover as PopoverPrimitive } from 'radix-ui';
+import * as React from 'react';
+import { cn } from '../lib/cn.js';
+function Popover(props) {
+    return _jsx(PopoverPrimitive.Root, { "data-slot": "popover", ...props });
+}
+function PopoverTrigger(props) {
+    return _jsx(PopoverPrimitive.Trigger, { "data-slot": "popover-trigger", ...props });
+}
+function PopoverAnchor(props) {
+    return _jsx(PopoverPrimitive.Anchor, { "data-slot": "popover-anchor", ...props });
+}
+function PopoverContent({ className, align = 'center', sideOffset = 6, ...props }) {
+    return (_jsx(PopoverPrimitive.Portal, { children: _jsx(PopoverPrimitive.Content, { "data-slot": "popover-content", align: align, sideOffset: sideOffset, className: cn('debugger-pop bg-card text-card-foreground border-border z-50 w-72 rounded-lg border p-3 shadow-xl shadow-black/30 outline-none', className), ...props }) }));
+}
+export { Popover, PopoverAnchor, PopoverContent, PopoverTrigger };

package/dist/debugger/ui/resizable.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentProps } from 'react';
+import { Group, Panel, Separator } from 'react-resizable-panels';
+declare function ResizablePanelGroup({ className, ...props }: ComponentProps<typeof Group>): import("react").JSX.Element;
+declare function ResizablePanel(props: ComponentProps<typeof Panel>): import("react").JSX.Element;
+/** A hairline divider with a wider invisible hit area that brightens while hovered or dragged. */
+declare function ResizableHandle({ className, ...props }: ComponentProps<typeof Separator>): import("react").JSX.Element;
+export { ResizableHandle, ResizablePanel, ResizablePanelGroup };

package/dist/debugger/ui/resizable.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Group, Panel, Separator } from 'react-resizable-panels';
+import { cn } from '../lib/cn.js';
+function ResizablePanelGroup({ className, ...props }) {
+    return (_jsx(Group, { "data-slot": "resizable-panel-group", className: cn('flex size-full aria-[orientation=vertical]:flex-col', className), ...props }));
+}
+function ResizablePanel(props) {
+    return _jsx(Panel, { "data-slot": "resizable-panel", ...props });
+}
+/** A hairline divider with a wider invisible hit area that brightens while hovered or dragged. */
+function ResizableHandle({ className, ...props }) {
+    return (_jsx(Separator, { "data-slot": "resizable-handle", className: cn('bg-border relative w-px shrink-0 outline-none after:absolute after:inset-y-0 after:left-1/2 after:w-2 after:-translate-x-1/2', 'data-[separator=active]:bg-ring data-[separator=focus]:bg-ring data-[separator=hover]:bg-ring/60 transition-colors duration-150', className), ...props }));
+}
+export { ResizableHandle, ResizablePanel, ResizablePanelGroup };

package/dist/debugger/ui/scroll-area.d.ts

@@ -1,7 +1,8 @@
 import { ScrollArea as ScrollAreaPrimitive } from 'radix-ui';
 import type { ComponentProps, Ref, UIEventHandler } from 'react';
-declare function ScrollArea({ className, children, viewportRef, onViewportScroll, horizontal, ...props }: ComponentProps<typeof ScrollAreaPrimitive.Root> & {
+declare function ScrollArea({ className, children, viewportRef, viewportClassName, onViewportScroll, horizontal, ...props }: ComponentProps<typeof ScrollAreaPrimitive.Root> & {
     viewportRef?: Ref<HTMLDivElement>;
+    viewportClassName?: string;
     onViewportScroll?: UIEventHandler<HTMLDivElement>;
     horizontal?: boolean;
 }): import("react").JSX.Element;

package/dist/debugger/ui/scroll-area.js

@@ -1,10 +1,12 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { ScrollArea as ScrollAreaPrimitive } from 'radix-ui';
 import { cn } from '../lib/cn.js';
-function ScrollArea({ className, children, viewportRef, onViewportScroll, horizontal = false, ...props }) {
-    return (_jsxs(ScrollAreaPrimitive.Root, { "data-slot": "scroll-area", type: "always", className: cn('relative overflow-hidden', className), ...props, children: [_jsx(ScrollAreaPrimitive.Viewport, { ref: viewportRef, "data-slot": "scroll-area-viewport", className: "size-full [scrollbar-width:none] rounded-[inherit] [&::-webkit-scrollbar]:hidden", onScroll: onViewportScroll, children: children }), _jsx(ScrollBar, {}), horizontal ? _jsx(ScrollBar, { orientation: "horizontal" }) : null, _jsx(ScrollAreaPrimitive.Corner, {})] }));
+function ScrollArea({ className, children, viewportRef, viewportClassName, onViewportScroll, horizontal = false, ...props }) {
+    return (_jsxs(ScrollAreaPrimitive.Root, { "data-slot": "scroll-area", type: "hover", scrollHideDelay: 400, className: cn('relative overflow-hidden', className), ...props, children: [_jsx(ScrollAreaPrimitive.Viewport, { ref: viewportRef, "data-slot": "scroll-area-viewport", className: cn(
+                // Radix wraps content in `display: table`, which lets long lines widen the viewport.
+                'size-full overscroll-contain rounded-[inherit] outline-none [&>div]:block!', viewportClassName), onScroll: onViewportScroll, children: children }), _jsx(ScrollBar, {}), horizontal ? _jsx(ScrollBar, { orientation: "horizontal" }) : null, _jsx(ScrollAreaPrimitive.Corner, {})] }));
 }
 function ScrollBar({ className, orientation = 'vertical', ...props }) {
-    return (_jsx(ScrollAreaPrimitive.ScrollAreaScrollbar, { "data-slot": "scroll-area-scrollbar", orientation: orientation, className: cn('flex touch-none p-px select-none', orientation === 'vertical' && 'h-full w-2 border-l border-l-transparent', orientation === 'horizontal' && 'h-2 flex-col border-t border-t-transparent', className), ...props, children: _jsx(ScrollAreaPrimitive.ScrollAreaThumb, { "data-slot": "scroll-area-thumb", className: "bg-border relative flex-1 rounded-full" }) }));
+    return (_jsx(ScrollAreaPrimitive.ScrollAreaScrollbar, { "data-slot": "scroll-area-scrollbar", orientation: orientation, className: cn('z-10 flex touch-none p-px transition-opacity duration-150 select-none data-[state=hidden]:opacity-0', orientation === 'vertical' && 'h-full w-2.5 border-l border-l-transparent', orientation === 'horizontal' && 'h-2.5 flex-col border-t border-t-transparent', className), ...props, children: _jsx(ScrollAreaPrimitive.ScrollAreaThumb, { "data-slot": "scroll-area-thumb", className: "bg-foreground/15 hover:bg-foreground/25 relative flex-1 rounded-full transition-colors" }) }));
 }
 export { ScrollArea, ScrollBar };

package/dist/debugger/ui/select.d.ts

@@ -0,0 +1,10 @@
+import { Select as SelectPrimitive } from 'radix-ui';
+import * as React from 'react';
+declare function Select(props: React.ComponentProps<typeof SelectPrimitive.Root>): React.JSX.Element;
+declare function SelectValue(props: React.ComponentProps<typeof SelectPrimitive.Value>): React.JSX.Element;
+declare function SelectTrigger({ className, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Trigger>): React.JSX.Element;
+declare function SelectContent({ className, children, position, sideOffset, ...props }: React.ComponentProps<typeof SelectPrimitive.Content>): React.JSX.Element;
+declare function SelectItem({ className, children, description, ...props }: React.ComponentProps<typeof SelectPrimitive.Item> & {
+    description?: string;
+}): React.JSX.Element;
+export { Select, SelectContent, SelectItem, SelectTrigger, SelectValue };

package/dist/debugger/ui/select.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Check, ChevronDown } from 'lucide-react';
+import { Select as SelectPrimitive } from 'radix-ui';
+import * as React from 'react';
+import { cn } from '../lib/cn.js';
+function Select(props) {
+    return _jsx(SelectPrimitive.Root, { "data-slot": "select", ...props });
+}
+function SelectValue(props) {
+    return _jsx(SelectPrimitive.Value, { "data-slot": "select-value", ...props });
+}
+function SelectTrigger({ className, children, ...props }) {
+    return (_jsxs(SelectPrimitive.Trigger, { "data-slot": "select-trigger", className: cn('text-muted-foreground hover:bg-accent hover:text-foreground focus-visible:ring-ring/50 data-[state=open]:bg-accent data-[state=open]:text-foreground flex h-7 items-center gap-1 rounded-md px-2 text-xs whitespace-nowrap transition-colors outline-none focus-visible:ring-[3px] disabled:opacity-50', className), ...props, children: [children, _jsx(SelectPrimitive.Icon, { asChild: true, children: _jsx(ChevronDown, { className: "size-3 opacity-60" }) })] }));
+}
+function SelectContent({ className, children, position = 'popper', sideOffset = 6, ...props }) {
+    return (_jsx(SelectPrimitive.Portal, { children: _jsx(SelectPrimitive.Content, { "data-slot": "select-content", position: position, sideOffset: sideOffset, className: cn('debugger-pop bg-card text-card-foreground border-border z-50 min-w-40 overflow-hidden rounded-lg border p-1 shadow-xl shadow-black/30', className), ...props, children: _jsx(SelectPrimitive.Viewport, { children: children }) }) }));
+}
+function SelectItem({ className, children, description, ...props }) {
+    return (_jsxs(SelectPrimitive.Item, { "data-slot": "select-item", className: cn('focus:bg-accent relative flex cursor-default flex-col items-start rounded-sm py-1.5 pr-2 pl-7 text-xs outline-none select-none data-disabled:opacity-50', className), ...props, children: [_jsx("span", { className: "absolute top-2 left-2 flex size-3.5 items-center justify-center", children: _jsx(SelectPrimitive.ItemIndicator, { children: _jsx(Check, { className: "size-3.5" }) }) }), _jsx(SelectPrimitive.ItemText, { children: children }), description ? (_jsx("span", { className: "text-muted-foreground text-[11px]", children: description })) : null] }));
+}
+export { Select, SelectContent, SelectItem, SelectTrigger, SelectValue };

package/dist/debugger/ui/tabs.js

@@ -6,10 +6,10 @@ function Tabs({ className, ...props }) {
     return (_jsx(TabsPrimitive.Root, { "data-slot": "tabs", className: cn('flex flex-col gap-2', className), ...props }));
 }
 function TabsList({ className, ...props }) {
-    return (_jsx(TabsPrimitive.List, { "data-slot": "tabs-list", className: cn('bg-secondary text-muted-foreground inline-flex h-8 w-fit items-center justify-center rounded-md p-0.5', className), ...props }));
+    return (_jsx(TabsPrimitive.List, { "data-slot": "tabs-list", className: cn('bg-secondary/70 text-muted-foreground inline-flex h-7 w-fit shrink-0 items-center justify-center rounded-md p-0.5', className), ...props }));
 }
 function TabsTrigger({ className, ...props }) {
-    return (_jsx(TabsPrimitive.Trigger, { "data-slot": "tabs-trigger", className: cn('focus-visible:ring-ring/50 data-[state=active]:bg-background data-[state=active]:text-foreground inline-flex h-7 items-center justify-center rounded-sm px-2.5 text-xs font-medium whitespace-nowrap transition-colors focus-visible:ring-[3px] focus-visible:outline-none disabled:pointer-events-none disabled:opacity-50', className), ...props }));
+    return (_jsx(TabsPrimitive.Trigger, { "data-slot": "tabs-trigger", className: cn('focus-visible:ring-ring/50 hover:text-foreground data-[state=active]:bg-background data-[state=active]:text-foreground inline-flex h-6 items-center justify-center rounded-sm px-2 text-[11px] font-medium whitespace-nowrap transition-colors focus-visible:ring-[3px] focus-visible:outline-none disabled:pointer-events-none disabled:opacity-50 data-[state=active]:shadow-sm', className), ...props }));
 }
 function TabsContent({ className, ...props }) {
     return (_jsx(TabsPrimitive.Content, { "data-slot": "tabs-content", className: cn('min-h-0 flex-1 outline-none', className), ...props }));

package/dist/debugger/ui/textarea.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare function Textarea({ className, ...props }: React.ComponentProps<'textarea'>): React.JSX.Element;
+export { Textarea };

package/dist/debugger/ui/textarea.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from 'react';
+import { cn } from '../lib/cn.js';
+function Textarea({ className, ...props }) {
+    return (_jsx("textarea", { "data-slot": "textarea", className: cn('border-input placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 flex field-sizing-content min-h-16 w-full rounded-md border bg-transparent px-2.5 py-2 text-[13px] leading-relaxed transition-[border-color,box-shadow] outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50', className), ...props }));
+}
+export { Textarea };

package/dist/evaluator/definitions-store.d.ts

@@ -0,0 +1,11 @@
+import { Context, Layer } from 'effect';
+import type { EvaluatorDefinition } from './definitions';
+export interface EvaluatorDefinitionStore {
+    get(name: string): EvaluatorDefinition | undefined;
+}
+declare const EvaluatorDefinitionsTag_base: Context.ServiceClass<EvaluatorDefinitionsTag, "looms/EvaluatorDefinitions", EvaluatorDefinitionStore>;
+export declare class EvaluatorDefinitionsTag extends EvaluatorDefinitionsTag_base {
+}
+export declare function makeEvaluatorDefinitionStore(definitions: ReadonlyArray<EvaluatorDefinition>): EvaluatorDefinitionStore;
+export declare const EvaluatorDefinitionsLive: (definitions: ReadonlyArray<EvaluatorDefinition>) => Layer.Layer<EvaluatorDefinitionsTag, never, never>;
+export {};

package/dist/evaluator/definitions-store.js

@@ -0,0 +1,8 @@
+import { Context, Layer } from 'effect';
+export class EvaluatorDefinitionsTag extends Context.Service()('looms/EvaluatorDefinitions') {
+}
+export function makeEvaluatorDefinitionStore(definitions) {
+    const map = new Map(definitions.map((def) => [def.name, def]));
+    return { get: (name) => map.get(name) };
+}
+export const EvaluatorDefinitionsLive = (definitions) => Layer.succeed(EvaluatorDefinitionsTag, makeEvaluatorDefinitionStore(definitions));

package/dist/evaluator/definitions.d.ts

@@ -0,0 +1,18 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { Schema } from 'effect';
+import { type JsonValue } from '@swirls/looms/core';
+import type { EvaluatorQuestions, EvaluatorRouteArgs, EvaluatorRouteDecision, EvaluatorSkipResult } from './types';
+export interface EvaluatorDefinition<TName extends string = string, TInput = JsonValue> {
+    readonly kind: 'evaluator';
+    readonly name: TName;
+    readonly description?: string;
+    /** Provider model id. Omit it to use the adapter default. */
+    readonly model?: string;
+    readonly input?: StandardSchemaV1<any, TInput> | Schema.ConstraintDecoder<TInput>;
+    readonly questions: EvaluatorQuestions;
+    state?(this: void, input: TInput): string;
+    skipModel?(this: void, input: TInput): EvaluatorSkipResult | undefined;
+    route?(this: void, args: EvaluatorRouteArgs): EvaluatorRouteDecision;
+}
+export type AnyEvaluatorDefinition = EvaluatorDefinition;
+export declare function defineEvaluator<TName extends string, TInput = JsonValue>(def: Omit<EvaluatorDefinition<TName, TInput>, 'kind'>): EvaluatorDefinition<TName, TInput>;

package/dist/evaluator/definitions.js

@@ -0,0 +1,4 @@
+import { defineKind } from '@swirls/looms/core';
+export function defineEvaluator(def) {
+    return defineKind('evaluator', def);
+}

package/dist/evaluator/effects.d.ts

@@ -0,0 +1,226 @@
+import { Schema } from 'effect';
+import { EvaluatorDefinitionsTag } from './definitions-store';
+import { EvaluatorTag } from './evaluator';
+export declare const evaluateEffect: NoInfer<import("@swirls/looms/core").EffectDefinition<{
+    readonly evaluationId: string;
+    readonly definitionName?: string | undefined;
+    readonly input?: Schema.Json | undefined;
+}, 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: 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: 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?: 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: 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: 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?: Schema.Json | undefined;
+        } | {
+            readonly timerAt: number;
+        };
+        readonly tag?: Schema.Json | undefined;
+    };
+}) | (Omit<import("@swirls/looms/core").EventInput, "payload" | "type"> & {
+    readonly type: "runtime.wait.satisfied";
+    readonly payload: {
+        readonly waitId: string;
+        readonly tag?: Schema.Json | undefined;
+        readonly event: {
+            readonly id: string;
+            readonly type: string;
+            readonly payload: Schema.Json;
+        };
+    };
+})>>;

package/dist/evaluator/effects.js

@@ -0,0 +1,132 @@
+import { Effect, Schema } from 'effect';
+import { stringifyJson, validateInputEffect } from '@swirls/looms/core';
+import { EvaluatorDefinitionsTag } from './definitions-store.js';
+import { EvaluatorTag } from './evaluator.js';
+import { evaluatorModule } from './scope.js';
+const EvaluateInput = Schema.Struct({
+    evaluationId: Schema.String,
+    definitionName: Schema.optional(Schema.String),
+    input: Schema.optional(Schema.Json),
+});
+function errorMessage(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}
+function capture(run) {
+    return Effect.try({
+        try: run,
+        catch: errorMessage,
+    }).pipe(Effect.match({
+        onFailure: (error) => ({ ok: false, error }),
+        onSuccess: (value) => ({ ok: true, value }),
+    }));
+}
+function failed(threadId, error) {
+    return [
+        {
+            type: 'runtime.thread.failed',
+            payload: { threadId, error },
+            threadId,
+        },
+    ];
+}
+export const evaluateEffect = evaluatorModule.effect({
+    type: 'evaluator.evaluate',
+    input: EvaluateInput,
+    execute: (input, ctx) => Effect.gen(function* () {
+        const threadId = ctx.threadId;
+        const definitions = yield* EvaluatorDefinitionsTag;
+        const evaluator = yield* EvaluatorTag;
+        const definition = input.definitionName ? definitions.get(input.definitionName) : undefined;
+        if (!definition) {
+            const name = input.definitionName ?? 'unknown';
+            return failed(threadId, `Unknown evaluator definition for ${name}`);
+        }
+        const rawInput = input.input ?? null;
+        const validated = definition.input
+            ? yield* validateInputEffect(definition.input, rawInput).pipe(Effect.match({
+                onFailure: (error) => ({ ok: false, error: error.message }),
+                onSuccess: (value) => ({ ok: true, value }),
+            }))
+            : { ok: true, value: rawInput };
+        if (!validated.ok) {
+            return failed(threadId, validated.error);
+        }
+        const subject = validated.value;
+        if (Object.keys(definition.questions).length === 0) {
+            return failed(threadId, 'Evaluator is missing questions');
+        }
+        const renderState = definition.state;
+        const stateText = renderState
+            ? yield* capture(() => renderState(subject))
+            : { ok: true, value: stringifyJson(subject) };
+        if (!stateText.ok) {
+            return failed(threadId, stateText.error);
+        }
+        const events = [
+            {
+                type: 'evaluator.requested',
+                payload: {
+                    evaluationId: input.evaluationId,
+                    definitionName: input.definitionName,
+                    state: stateText.value,
+                    model: definition.model,
+                },
+                threadId,
+            },
+        ];
+        const skipModel = definition.skipModel;
+        const skipped = skipModel
+            ? yield* capture(() => skipModel(subject))
+            : { ok: true, value: undefined };
+        if (!skipped.ok) {
+            return failed(threadId, skipped.error);
+        }
+        let answers = {};
+        let usage;
+        let decision = { route: 'continue', reason: 'unavailable' };
+        if (skipped.value) {
+            answers = skipped.value.answers ?? {};
+            decision = { route: skipped.value.route, reason: skipped.value.reason };
+        }
+        else {
+            const evaluated = yield* evaluator
+                .evaluate({
+                model: definition.model,
+                state: stateText.value,
+                questions: definition.questions,
+            })
+                .pipe(Effect.match({
+                onFailure: () => ({ ok: false }),
+                onSuccess: (value) => ({ ok: true, value }),
+            }));
+            if (evaluated.ok) {
+                answers = evaluated.value.answers;
+                usage = evaluated.value.usage;
+                const route = definition.route;
+                if (route) {
+                    const routed = yield* capture(() => route({ answers, input: subject }));
+                    if (!routed.ok) {
+                        return failed(threadId, routed.error);
+                    }
+                    decision = { route: routed.value.route, reason: routed.value.reason ?? 'model' };
+                }
+                else {
+                    decision = { route: 'continue', reason: 'model' };
+                }
+            }
+        }
+        events.push({
+            type: 'evaluator.evaluated',
+            payload: {
+                evaluationId: input.evaluationId,
+                definitionName: input.definitionName,
+                answers,
+                route: decision.route,
+                reason: decision.reason,
+                usage,
+            },
+            threadId,
+        });
+        return events;
+    }),
+});

package/dist/evaluator/evaluator.d.ts

@@ -0,0 +1,24 @@
+import { Context, Effect, Layer } from 'effect';
+import type { EvaluatorAdapter } from './types';
+declare const EvaluatorError_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: "EvaluatorError";
+} & Readonly<A>;
+export declare class EvaluatorError extends EvaluatorError_base<{
+    readonly cause: unknown;
+    readonly message: string;
+}> {
+    constructor(cause: unknown);
+}
+export interface EvaluatorService {
+    readonly evaluate: (args: Parameters<EvaluatorAdapter['evaluate']>[0]) => Effect.Effect<Awaited<ReturnType<EvaluatorAdapter['evaluate']>>, EvaluatorError>;
+}
+export declare function evaluatorFromAdapter(adapter: EvaluatorAdapter): EvaluatorService;
+declare const EvaluatorTag_base: Context.ServiceClass<EvaluatorTag, "looms/Evaluator", EvaluatorService>;
+export declare class EvaluatorTag extends EvaluatorTag_base {
+}
+export interface StubEvaluatorPolicy {
+    evaluate?: EvaluatorAdapter['evaluate'];
+}
+export declare const makeStubEvaluator: (policy?: StubEvaluatorPolicy) => EvaluatorService;
+export declare const StubEvaluatorLive: (policy?: StubEvaluatorPolicy) => Layer.Layer<EvaluatorTag, never, never>;
+export {};

package/dist/evaluator/evaluator.js

@@ -0,0 +1,67 @@
+import { Context, Data, Effect, Layer } from 'effect';
+export class EvaluatorError extends Data.TaggedError('EvaluatorError') {
+    constructor(cause) {
+        super({
+            cause,
+            message: cause instanceof Error ? cause.message : String(cause),
+        });
+        this.name = 'EvaluatorError';
+    }
+}
+export function evaluatorFromAdapter(adapter) {
+    return {
+        evaluate: (args) => Effect.tryPromise({
+            try: () => adapter.evaluate(args),
+            catch: (cause) => new EvaluatorError(cause),
+        }),
+    };
+}
+export class EvaluatorTag extends Context.Service()('looms/Evaluator') {
+}
+function defaultStubEvaluate(args) {
+    const text = args.state.toLowerCase();
+    const high = /\b(error|fail|fatal|dispute|urgent)\b/.test(text);
+    const low = /\b(routine|resolved|duplicate)\b/.test(text);
+    const answers = Object.fromEntries(Object.entries(args.questions).map(([name, question]) => {
+        if (question.type === 'boolean') {
+            return [
+                name,
+                {
+                    type: 'boolean',
+                    value: high,
+                    probability: high ? 0.95 : low ? 0.02 : 0.4,
+                },
+            ];
+        }
+        if (question.type === 'choice') {
+            const allowed = Object.keys(question.criteria);
+            const preferred = high ? ['critical', 'high'] : low ? ['low'] : ['normal'];
+            const value = preferred.find((item) => allowed.includes(item)) ?? allowed[0] ?? 'low';
+            return [
+                name,
+                {
+                    type: 'choice',
+                    value,
+                },
+            ];
+        }
+        return [
+            name,
+            {
+                type: 'score',
+                value: high ? 4 : low ? 0 : 2,
+            },
+        ];
+    }));
+    return {
+        answers,
+        usage: { input: 0, output: 0 },
+    };
+}
+export const makeStubEvaluator = (policy = {}) => ({
+    evaluate: (args) => Effect.tryPromise({
+        try: () => Promise.resolve((policy.evaluate ?? defaultStubEvaluate)(args)),
+        catch: (cause) => new EvaluatorError(cause),
+    }),
+});
+export const StubEvaluatorLive = (policy) => Layer.succeed(EvaluatorTag, makeStubEvaluator(policy));