@swirls/looms 0.0.2 → 0.2.0

package/dist/core/ids.d.ts

@@ -1,6 +1,11 @@
 export declare function createEventId(): string;
 export declare function createRunId(): string;
 export declare function createThreadId(): string;
+/**
+ * A UUID-shaped id derived only from `parts`, so a reducer that replays the same events names the same
+ * child thread every time.
+ */
+export declare function deterministicThreadId(...parts: readonly (string | number)[]): string;
 export declare function createWaitId(scope?: string, tag?: string | number): string;
 export declare function createEffectId(threadId: string, causingSeqOrTag: number | string, index?: number): string;
 export declare function parseEffectId(effectId: string): {

package/dist/core/ids.js

@@ -1,8 +1,12 @@
-import { Predicate } from 'effect';
+import { DateTime, Predicate } from 'effect';
 let counter = 0;
 function token() {
     counter += 1;
-    return `${Date.now().toString(36)}_${counter.toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+    const timestamp = DateTime.toEpochMillis(DateTime.nowUnsafe());
+    // Synchronous ID factories need process-independent entropy without an Effect runtime.
+    // oxlint-disable-next-line effecttsgo/crypto-random-uuid
+    const entropy = globalThis.crypto.randomUUID().replaceAll('-', '');
+    return `${timestamp.toString(36)}_${counter.toString(36)}_${entropy}`;
 }
 export function createEventId() {
     return `evt_${token()}`;
@@ -13,6 +17,35 @@ export function createRunId() {
 export function createThreadId() {
     return `thr_${token()}`;
 }
+function fnv1a32(value, seed) {
+    let hash = seed >>> 0;
+    for (let index = 0; index < value.length; index++) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+/**
+ * A UUID-shaped id derived only from `parts`, so a reducer that replays the same events names the same
+ * child thread every time.
+ */
+export function deterministicThreadId(...parts) {
+    const source = parts.join(':');
+    let reversed = '';
+    for (let index = source.length - 1; index >= 0; index--) {
+        reversed += source.charAt(index);
+    }
+    const hex = [
+        fnv1a32(source, 0x811c9dc5),
+        fnv1a32(source, 0x9e3779b9),
+        fnv1a32(reversed, 0x85ebca6b),
+        fnv1a32(reversed, 0xc2b2ae35),
+    ].join('');
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-5${hex.slice(13, 16)}-${((Number.parseInt(hex.slice(16, 18), 16) & 0x3f) |
+        0x80)
+        .toString(16)
+        .padStart(2, '0')}${hex.slice(18, 20)}-${hex.slice(20)}`;
+}
 export function createWaitId(scope, tag) {
     if (scope !== undefined && tag !== undefined) {
         return `wait_${scope}_${tag}`;

package/dist/core/index.d.ts

@@ -1,6 +1,7 @@
 export type * from './types';
-export { asJson, cleanUndefined, fromJsonStruct, isJsonNumber, isJsonObject, isJsonString, } from './types';
+export { asJson, cleanUndefined, isJsonNumber, isJsonObject, isJsonString, stringifyJson, stringifyJsonPretty, } from './types';
 export * from './ids';
+export * from './worker-callback';
 export * from './schema';
 export * from './validate-event';
 export * from './envelope';
@@ -14,6 +15,7 @@ export * from './fold';
 export * from './replay';
 export * from './projection';
 export * from './module';
+export * from './kind';
 export * from './module-scope';
 export * from './compose';
 export * from './store';
@@ -24,3 +26,7 @@ export * from './event-codec';
 export * from './serialize';
 export * from './coalesce';
 export * from './event-index';
+export * from './limits';
+export * from './definition-store';
+export * from './published';
+export type { DebuggerHost, DebuggerRequest } from './debugger-host';

package/dist/core/index.js

@@ -1,5 +1,6 @@
-export { asJson, cleanUndefined, fromJsonStruct, isJsonNumber, isJsonObject, isJsonString, } from './types.js';
+export { asJson, cleanUndefined, isJsonNumber, isJsonObject, isJsonString, stringifyJson, stringifyJsonPretty, } from './types.js';
 export * from './ids.js';
+export * from './worker-callback.js';
 export * from './schema.js';
 export * from './validate-event.js';
 export * from './envelope.js';
@@ -13,6 +14,7 @@ export * from './fold.js';
 export * from './replay.js';
 export * from './projection.js';
 export * from './module.js';
+export * from './kind.js';
 export * from './module-scope.js';
 export * from './compose.js';
 export * from './store.js';
@@ -23,3 +25,6 @@ export * from './event-codec.js';
 export * from './serialize.js';
 export * from './coalesce.js';
 export * from './event-index.js';
+export * from './limits.js';
+export * from './definition-store.js';
+export * from './published.js';

package/dist/core/kind.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Stamp a startable `{ kind, name }` definition.
+ *
+ * `defineAgent` and `defineWorkflow` are specialized helpers for those kinds.
+ * Custom thread types should use `createKind` / `defineKind` instead of
+ * assembling the object by hand.
+ */
+export declare function defineKind<TKind extends string, TDef extends {
+    readonly name: string;
+}>(kind: TKind, def: TDef): TDef & {
+    readonly kind: TKind;
+};
+export interface KindBuilder<TKind extends string> {
+    readonly kind: TKind;
+    define<TDef extends {
+        readonly name: string;
+    }>(def: TDef): TDef & {
+        readonly kind: TKind;
+    };
+}
+/** Bind `define` to one kind so each custom type has a builder, like `defineAgent`. */
+export declare function createKind<TKind extends string>(kind: TKind): KindBuilder<TKind>;

package/dist/core/kind.js

@@ -0,0 +1,17 @@
+/**
+ * Stamp a startable `{ kind, name }` definition.
+ *
+ * `defineAgent` and `defineWorkflow` are specialized helpers for those kinds.
+ * Custom thread types should use `createKind` / `defineKind` instead of
+ * assembling the object by hand.
+ */
+export function defineKind(kind, def) {
+    return { ...def, kind };
+}
+/** Bind `define` to one kind so each custom type has a builder, like `defineAgent`. */
+export function createKind(kind) {
+    return {
+        kind,
+        define: (def) => defineKind(kind, def),
+    };
+}

package/dist/core/limits.d.ts

@@ -0,0 +1,34 @@
+import type { AppendableEvent } from './envelope';
+import type { RunSnapshot } from './snapshot-store';
+import type { JsonValue } from './types';
+export declare const DEFAULT_MAX_EVENT_BYTES: number;
+export declare const DEFAULT_MAX_SNAPSHOT_BYTES: number;
+declare const EventPayloadTooLargeError_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: "EventPayloadTooLargeError";
+} & Readonly<A>;
+export declare class EventPayloadTooLargeError extends EventPayloadTooLargeError_base<{
+    readonly runId: string;
+    readonly eventType: string;
+    readonly bytes: number;
+    readonly maxBytes: number;
+    readonly message: string;
+}> {
+    constructor(runId: string, eventType: string, bytes: number, maxBytes: number);
+}
+declare const SnapshotPayloadTooLargeError_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: "SnapshotPayloadTooLargeError";
+} & Readonly<A>;
+export declare class SnapshotPayloadTooLargeError extends SnapshotPayloadTooLargeError_base<{
+    readonly runId: string;
+    readonly bytes: number;
+    readonly maxBytes: number;
+    readonly message: string;
+}> {
+    constructor(runId: string, bytes: number, maxBytes: number);
+}
+/** Size of `value` as serialized JSON, in UTF-8 bytes. */
+export declare function utf8JsonBytes(value: JsonValue | Readonly<object>): number;
+/** Validate every event before any storage mutation begins. */
+export declare function assertEventByteLimits(runId: string, events: ReadonlyArray<AppendableEvent>, maxBytes?: number): void;
+export declare function assertSnapshotByteLimit(snapshot: RunSnapshot, maxBytes?: number): void;
+export {};

package/dist/core/limits.js

@@ -0,0 +1,46 @@
+import { Data } from 'effect';
+export const DEFAULT_MAX_EVENT_BYTES = 1024 * 1024;
+export const DEFAULT_MAX_SNAPSHOT_BYTES = 8 * 1024 * 1024;
+const utf8 = new TextEncoder();
+export class EventPayloadTooLargeError extends Data.TaggedError('EventPayloadTooLargeError') {
+    constructor(runId, eventType, bytes, maxBytes) {
+        super({
+            runId,
+            eventType,
+            bytes,
+            maxBytes,
+            message: `EventPayloadTooLarge: event "${eventType}" for run "${runId}" is ${bytes} UTF-8 bytes; limit is ${maxBytes}`,
+        });
+        this.name = 'EventPayloadTooLargeError';
+    }
+}
+export class SnapshotPayloadTooLargeError extends Data.TaggedError('SnapshotPayloadTooLargeError') {
+    constructor(runId, bytes, maxBytes) {
+        super({
+            runId,
+            bytes,
+            maxBytes,
+            message: `SnapshotPayloadTooLarge: snapshot for run "${runId}" is ${bytes} UTF-8 bytes; limit is ${maxBytes}`,
+        });
+        this.name = 'SnapshotPayloadTooLargeError';
+    }
+}
+/** Size of `value` as serialized JSON, in UTF-8 bytes. */
+export function utf8JsonBytes(value) {
+    return utf8.encode(JSON.stringify(value)).byteLength;
+}
+/** Validate every event before any storage mutation begins. */
+export function assertEventByteLimits(runId, events, maxBytes = DEFAULT_MAX_EVENT_BYTES) {
+    for (const event of events) {
+        const bytes = utf8JsonBytes({ ...event, runId, seq: event.seq ?? 0 });
+        if (bytes > maxBytes) {
+            throw new EventPayloadTooLargeError(runId, event.type, bytes, maxBytes);
+        }
+    }
+}
+export function assertSnapshotByteLimit(snapshot, maxBytes = DEFAULT_MAX_SNAPSHOT_BYTES) {
+    const bytes = utf8JsonBytes(snapshot);
+    if (bytes > maxBytes) {
+        throw new SnapshotPayloadTooLargeError(snapshot.runId, bytes, maxBytes);
+    }
+}

package/dist/core/match.d.ts

@@ -4,5 +4,6 @@ import type { JsonValue } from './types';
 export declare function isSubset(match: JsonValue, payload: JsonValue): boolean;
 export declare function matchesWait(event: EventEnvelope, on: WaitCondition): boolean;
 export declare function matchingWaits<T extends {
+    waitId: string;
     on: WaitCondition;
 }>(event: EventEnvelope, waits: readonly T[]): T[];

package/dist/core/match.js

@@ -54,5 +54,14 @@ export function matchesWait(event, on) {
     return isSubset(on.match, event.payload);
 }
 export function matchingWaits(event, waits) {
-    return waits.filter((record) => matchesWait(event, record.on));
+    return waits.filter((record) => {
+        if (isWaitOnTimer(record.on)) {
+            if (event.type !== 'runtime.timer.fired' || !Predicate.isObject(event.payload)) {
+                return false;
+            }
+            const firedWaitId = event.payload.waitId;
+            return Predicate.isString(firedWaitId) && firedWaitId === record.waitId;
+        }
+        return matchesWait(event, record.on);
+    });
 }

package/dist/core/module-scope.d.ts

@@ -1,9 +1,9 @@
 import type { Layer } from 'effect';
 import { type CatalogEntries, type EventCatalog, type EventInputOf, type EventsOfCatalog, type InferPayload } from './catalog';
 import type { EventsOf, ProtocolEvents } from './compose';
-import { type EffectDefinition, type EffectHandlerResult, type EmitEffect, type RetryPolicy, type RuntimeEffect, type ScopedEffectContext } from './effects';
+import { type EffectDefinition, type EffectExecution, type EffectHandlerResult, type EmitEffect, type RetryPolicy, type RuntimeEffect, type ScopedEffectContext } from './effects';
 import type { EventEnvelope, EventInput } from './envelope';
-import { type AnyRuntimeModule, type EffectMiddleware, type RuntimeModule, type DefinitionRef, type RuntimeModuleDependency } from './module';
+import { type AnyRuntimeModule, type EffectMiddleware, type RuntimeModule, type DefinitionRef, type RuntimeModuleDependency, type SignalInterruptRule } from './module';
 import { type ProjectionDefinition } from './projection';
 import type { InferDefinedSchema, InferSchemaOutput, SchemaInput } from './schema';
 import { type StartContext, type ThreadContext, type ThreadDefinition } from './thread';
@@ -32,40 +32,41 @@ export interface ModuleScope<TNamespace extends string, U extends EventEnvelope<
     readonly events?: TEvents;
     readonly observes?: TObserves;
     readonly dependencies?: readonly RuntimeModuleDependency[];
-    thread<TShape, TInputSchema extends SchemaInput | undefined = undefined>(def: {
-        readonly kind: string;
-        readonly shape: TShape;
-        readonly input?: TInputSchema;
-        initialState(ctx: StartContext<InferDefinedSchema<TInputSchema>>): InferSchemaOutput<TShape>;
-        step(state: InferSchemaOutput<TShape>, event: U, ctx: ThreadContext): InferSchemaOutput<TShape>;
-        effects?(state: InferSchemaOutput<TShape>, ctx: ThreadContext): RuntimeEffect[];
-    }): ThreadDefinition<InferSchemaOutput<TShape>>;
     thread<S = JsonValue, TInputSchema extends SchemaInput | undefined = undefined>(def: {
         readonly kind: string;
-        readonly shape?: unknown;
+        readonly shape?: undefined;
         readonly input?: TInputSchema;
         initialState(ctx: StartContext<InferDefinedSchema<TInputSchema>>): S;
         step(state: S, event: U, ctx: ThreadContext): S;
         effects?(state: S, ctx: ThreadContext): RuntimeEffect[];
     }): ThreadDefinition<S>;
-    projection<TShape>(def: {
-        readonly name: string;
+    thread<TShape extends SchemaInput, TInputSchema extends SchemaInput | undefined = undefined>(def: {
+        readonly kind: string;
         readonly shape: TShape;
-        readonly initialState: InferSchemaOutput<TShape>;
-        reduce(state: InferSchemaOutput<TShape>, event: U): InferSchemaOutput<TShape>;
-    }): ProjectionDefinition<InferSchemaOutput<TShape>>;
+        readonly input?: TInputSchema;
+        initialState(ctx: StartContext<InferDefinedSchema<TInputSchema>>): InferSchemaOutput<TShape>;
+        step(state: NoInfer<InferSchemaOutput<TShape>>, event: U, ctx: ThreadContext): InferSchemaOutput<TShape>;
+        effects?(state: NoInfer<InferSchemaOutput<TShape>>, ctx: ThreadContext): RuntimeEffect[];
+    }): ThreadDefinition<InferSchemaOutput<TShape>>;
     projection<S>(def: {
         readonly name: string;
-        readonly shape?: unknown;
+        readonly shape?: undefined;
         readonly initialState: S;
         reduce(state: S, event: U): S;
     }): ProjectionDefinition<S>;
-    effect<TSchema = undefined, TInput = InferDefinedSchema<TSchema>, R = never, E extends EventInputOf<U> = EventInputOf<U>>(def: {
+    projection<TShape extends SchemaInput>(def: {
+        readonly name: string;
+        readonly shape: TShape;
+        readonly initialState: InferSchemaOutput<TShape>;
+        reduce(state: NoInfer<InferSchemaOutput<TShape>>, event: U): InferSchemaOutput<TShape>;
+    }): ProjectionDefinition<InferSchemaOutput<TShape>>;
+    effect<TSchema extends SchemaInput | undefined = undefined, TInput = InferDefinedSchema<TSchema>, R = never, HandlerError = never>(def: {
         type: `${TNamespace}.${string}`;
         input?: TSchema;
         retry?: RetryPolicy;
-        execute: (input: TInput, ctx: ScopedEffectContext<EventInputOf<U>>) => EffectHandlerResult<R, EventInputOf<U>>;
-    }): NoInfer<EffectDefinition<TInput, R, E>>;
+        execution?: EffectExecution;
+        execute?: (input: TInput, ctx: ScopedEffectContext<EventInputOf<U>>) => EffectHandlerResult<R, EventInputOf<U>, HandlerError>;
+    }): NoInfer<EffectDefinition<TInput, R, EventInputOf<U>>>;
     input<K extends keyof (TEvents extends EventCatalog<any, infer E> ? E : never) & string>(key: K, payload: InferPayload<(TEvents extends EventCatalog<any, infer E> ? E : never)[K]>, meta?: Omit<EventInput, 'type' | 'payload'>): Omit<EventInput, 'type' | 'payload'> & {
         readonly type: `${TNamespace}.${K}`;
         readonly payload: InferPayload<(TEvents extends EventCatalog<any, infer E> ? E : never)[K]>;
@@ -92,6 +93,7 @@ export declare function defineModule<const N extends string, E extends EventCata
     readonly projections?: PR;
     readonly definitions?: readonly DefinitionRef[];
     readonly middleware?: readonly EffectMiddleware[];
+    readonly interruptsOnSignal?: SignalInterruptRule;
 } & ModuleServicesConfig<EffectRequirementsOf<FX>>): RuntimeModule<N, Extract<ModuleCatalog<N, E>, EventCatalog>, FX, TH, PR> & {
     readonly effects: FX;
     readonly threads: TH;

package/dist/core/module-scope.js

@@ -4,11 +4,7 @@ import {} from './module.js';
 import { defineProjection } from './projection.js';
 import { defineThread, } from './thread.js';
 import { asJson } from './types.js';
-function buildScopeInput(namespace, events, key, payload, meta) {
-    if (events) {
-        // SAFETY: catalog input produces typed EventInput for the catalog entry.
-        return events.input(key, payload, meta);
-    }
+function buildScopeInput(namespace, key, payload, meta) {
     return {
         ...meta,
         type: `${namespace}.${key}`,
@@ -33,40 +29,54 @@ export function createModuleScope(options) {
             return defineEffect(def);
         },
         input(key, payload, meta) {
-            return buildScopeInput(namespace, events, key, payload, meta);
+            return buildScopeInput(namespace, key, payload, meta);
         },
         emit(key, payload, meta) {
-            return emit(buildScopeInput(namespace, events, key, payload, meta));
+            return emit(buildScopeInput(namespace, key, payload, meta));
         },
     };
     return scope;
 }
-/** Construct a complete module. Only members returned by setup are installed. */
-/* oxlint-disable anti-slop/no-runtime-typeof, anti-slop/no-chained-type-assertions, anti-slop/no-conditional-empty-object-spread, anti-slop/require-safety-comment-for-type-assertion -- This compatibility boundary normalizes either a module builder or its finished catalog while preserving its generic member types. */
+function isEventCatalog(source) {
+    return 'namespace' in source && 'entries' in source;
+}
+function isModuleScope(source) {
+    return 'thread' in source && 'effect' in source;
+}
 export function defineModule(options, setup) {
     const source = options.events;
-    // SAFETY: catalogs have an input builder; inline entries are normalized once here.
-    const events = (source &&
-        (typeof source.input === 'function'
+    const events = source
+        ? isEventCatalog(source)
             ? source
-            : defineEventCatalog(options.namespace, source)));
-    const scope = typeof options.effect === 'function'
-        ? options
-        : createModuleScope({ ...options, events });
+            : defineEventCatalog(options.namespace, source)
+        : undefined;
+    const scope = isModuleScope(options) ? options : createModuleScope({ ...options, events });
     const members = setup(scope);
-    return {
+    const module = {
         namespace: options.namespace,
         protocolVersion: options.protocolVersion,
-        events: events,
-        ...(options.observes ? { observes: options.observes } : {}),
-        ...(options.dependencies ? { dependencies: options.dependencies } : {}),
-        ...(members.definitions ? { definitions: members.definitions } : {}),
-        ...(members.middleware ? { middleware: members.middleware } : {}),
-        ...(members.services ? { services: members.services } : {}),
-        // SAFETY: absent member bags use the corresponding empty-object generic defaults.
-        effects: (members.effects ?? {}),
-        threads: (members.threads ?? {}),
-        projections: (members.projections ?? {}),
+        events,
+        effects: members.effects ?? {},
+        threads: members.threads ?? {},
+        projections: members.projections ?? {},
     };
+    if (options.observes) {
+        module.observes = options.observes;
+    }
+    if (options.dependencies) {
+        module.dependencies = options.dependencies;
+    }
+    if (members.definitions) {
+        module.definitions = members.definitions;
+    }
+    if (members.middleware) {
+        module.middleware = members.middleware;
+    }
+    if (members.services) {
+        module.services = members.services;
+    }
+    if (members.interruptsOnSignal) {
+        module.interruptsOnSignal = members.interruptsOnSignal;
+    }
+    return module;
 }
-/* oxlint-enable anti-slop/no-runtime-typeof, anti-slop/no-chained-type-assertions, anti-slop/no-conditional-empty-object-spread, anti-slop/require-safety-comment-for-type-assertion */

package/dist/core/module.d.ts

@@ -1,4 +1,4 @@
-import type { Effect, Layer } from 'effect';
+import type { Context, Effect, Layer } from 'effect';
 import type { EventCatalog } from './catalog';
 import type { EffectContext, EffectDefinition, RuntimeEffect } from './effects';
 import type { EventInput } from './envelope';
@@ -8,6 +8,12 @@ import type { ThreadDefinition } from './thread';
 import type { JsonValue } from './types';
 export type NextEffectHandler = (effect: RuntimeEffect, ctx: EffectContext) => Effect.Effect<ReadonlyArray<EventInput>, Error>;
 export type EffectMiddleware = (effect: RuntimeEffect, ctx: EffectContext, next: NextEffectHandler) => Effect.Effect<ReadonlyArray<EventInput>, Error>;
+/**
+ * Names the threads whose in-process effects an admitted signal event interrupts, so a running
+ * effect (such as a model call) can stop early. Return an empty array when the event interrupts
+ * nothing.
+ */
+export type SignalInterruptRule = (event: EventInput) => readonly string[];
 export interface RuntimeModuleDependency {
     readonly namespace: string;
     readonly protocolVersion?: string;
@@ -16,13 +22,19 @@ export interface RuntimeModuleDependency {
 export interface DefinitionRef {
     readonly kind: string;
     readonly name: string;
+    readonly version?: string;
     readonly input?: SchemaInput | undefined;
+    readonly description?: string | undefined;
 }
-/** A definition registered on a host, keyed by `${kind}:${name}`. */
+export declare const DEFAULT_DEFINITION_VERSION = "v1";
+export declare function definitionKey(kind: string, name: string, version: string): string;
+/** A definition registered on a host, keyed by `${kind}:${name}@${version}`. */
 export interface RegisteredDefinition {
     readonly kind: string;
     readonly name: string;
+    readonly version: string;
     readonly input?: SchemaInput | undefined;
+    readonly description?: string | undefined;
     readonly value: DefinitionRef;
 }
 /**
@@ -44,7 +56,7 @@ export interface RuntimeModule<TNamespace extends string = string, TEvents exten
     readonly [key: string]: ProjectionDefinition;
 } = {
     readonly [key: string]: ProjectionDefinition;
-}, TServices = any> {
+}, TServices = Context.Service.Any> {
     readonly namespace: TNamespace;
     readonly protocolVersion: string;
     readonly events?: TEvents;
@@ -55,6 +67,7 @@ export interface RuntimeModule<TNamespace extends string = string, TEvents exten
     readonly definitions?: readonly DefinitionRef[];
     readonly dependencies?: readonly RuntimeModuleDependency[];
     readonly middleware?: readonly EffectMiddleware[];
+    readonly interruptsOnSignal?: SignalInterruptRule;
     /** Host-side services this module's effect handlers need (an LLM, a definition lookup, a DB pool). */
     readonly services?: () => Layer.Layer<TServices>;
 }
@@ -64,9 +77,9 @@ export declare function defineRuntimeModule<TNamespace extends string, TEvents e
     readonly [key: string]: ThreadDefinition;
 }, TProjections extends {
     readonly [key: string]: ProjectionDefinition;
-}, TServices = any>(module: RuntimeModule<TNamespace, TEvents, TEffects, TThreads, TProjections, TServices>): RuntimeModule<TNamespace, TEvents, TEffects, TThreads, TProjections, TServices>;
+}, TServices = Context.Service.Any>(module: RuntimeModule<TNamespace, TEvents, TEffects, TThreads, TProjections, TServices>): RuntimeModule<TNamespace, TEvents, TEffects, TThreads, TProjections, TServices>;
 export type AnyRuntimeModule = RuntimeModule<string, EventCatalog, {
-    readonly [name: string]: EffectDefinition;
+    readonly [name: string]: EffectDefinition<any, any, any>;
 }, {
     readonly [kind: string]: ThreadDefinition;
 }, {

package/dist/core/module.js

@@ -1,3 +1,7 @@
+export const DEFAULT_DEFINITION_VERSION = 'v1';
+export function definitionKey(kind, name, version) {
+    return `${kind}:${name}@${version}`;
+}
 export function defineRuntimeModule(module) {
     return module;
 }

package/dist/core/projection.d.ts

@@ -1,6 +1,6 @@
 import { Schema, Stream, type Effect } from 'effect';
 import type { EventEnvelope } from './envelope';
-import type { InferSchemaOutput } from './schema';
+import type { InferSchemaOutput, SchemaInput } from './schema';
 import type { RunState, ThreadRecord } from './state';
 export interface ProjectionDefinition<S = unknown> {
     readonly name: string;
@@ -8,18 +8,18 @@ export interface ProjectionDefinition<S = unknown> {
     initialState: S;
     reduce(state: S, event: EventEnvelope): S;
 }
-export declare function defineProjection<TShape>(def: {
-    readonly name: string;
-    readonly shape: TShape;
-    readonly initialState: InferSchemaOutput<TShape>;
-    reduce(state: InferSchemaOutput<TShape>, event: EventEnvelope): InferSchemaOutput<TShape>;
-}): ProjectionDefinition<InferSchemaOutput<TShape>>;
 export declare function defineProjection<S = unknown>(def: {
     readonly name: string;
-    readonly shape?: unknown;
+    readonly shape?: undefined;
     readonly initialState: S;
     reduce(state: S, event: EventEnvelope): S;
 }): ProjectionDefinition<S>;
+export declare function defineProjection<TShape extends SchemaInput>(def: {
+    readonly name: string;
+    readonly shape: TShape;
+    readonly initialState: InferSchemaOutput<TShape>;
+    reduce(state: NoInfer<InferSchemaOutput<TShape>>, event: EventEnvelope): InferSchemaOutput<TShape>;
+}): ProjectionDefinition<InferSchemaOutput<TShape>>;
 export declare function foldProjection<S>(projection: ProjectionDefinition<S>, events: readonly EventEnvelope[], initial?: S): S;
 /** Fold a projection over events, skipping ephemeral ones. */
 export declare function project<S>(definition: ProjectionDefinition<S>, events: readonly EventEnvelope[], from?: S): S;
@@ -29,6 +29,7 @@ export interface ThreadNode {
     threadId: string;
     kind: string;
     definitionName: string;
+    definitionVersion: string;
     status: ThreadRecord['status'];
     parentThreadId: string | null;
     children: ThreadNode[];
@@ -49,28 +50,27 @@ export interface TreeBuildState {
         [threadId: string]: string[];
     };
 }
-export declare const TreeBuildStateSchema: Schema.Schema<TreeBuildState>;
 export declare const threadTree: ProjectionDefinition<TreeBuildState>;
 export declare function toThreadTree(state: TreeBuildState): ThreadTree;
 export declare function treeFromRun(state: RunState): ThreadTree;
 export declare const TimelineEntrySchema: Schema.Struct<{
-    readonly seq: Schema.Number;
+    readonly seq: Schema.Finite;
     readonly id: Schema.String;
     readonly type: Schema.String;
     readonly threadId: Schema.NullOr<Schema.String>;
     readonly causationId: Schema.NullOr<Schema.String>;
     readonly effectId: Schema.NullOr<Schema.String>;
-    readonly ts: Schema.Number;
+    readonly ts: Schema.Finite;
 }>;
 export type TimelineEntry = Schema.Schema.Type<typeof TimelineEntrySchema>;
 export declare const TimelineSchema: Schema.mutable<Schema.$Array<Schema.Struct<{
-    readonly seq: Schema.Number;
+    readonly seq: Schema.Finite;
     readonly id: Schema.String;
     readonly type: Schema.String;
     readonly threadId: Schema.NullOr<Schema.String>;
     readonly causationId: Schema.NullOr<Schema.String>;
     readonly effectId: Schema.NullOr<Schema.String>;
-    readonly ts: Schema.Number;
+    readonly ts: Schema.Finite;
 }>>>;
 export declare const timeline: ProjectionDefinition<{
     readonly seq: number;