@swirls/looms 0.0.1

package/dist/core/fold.js

@@ -0,0 +1,362 @@
+import { Predicate, Stream } from 'effect';
+import { isWithdrawnError } from './effects.js';
+import { createEffectId } from './ids.js';
+import { emptyRunState } from './state.js';
+import { isTerminalStatus } from './thread.js';
+function payloadObject(event) {
+    const payload = event.payload;
+    if (payload === null || Array.isArray(payload)) {
+        return {};
+    }
+    if (Predicate.isReadonlyObject(payload)) {
+        return payload;
+    }
+    return {};
+}
+function readString(obj, key) {
+    const value = obj[key];
+    return Predicate.isString(value) ? value : undefined;
+}
+function cloneState(state) {
+    return {
+        runId: state.runId,
+        status: state.status,
+        rootThreadId: state.rootThreadId,
+        threads: { ...state.threads },
+        waits: { ...state.waits },
+        outstandingEffects: [...state.outstandingEffects],
+        completedEffectIds: state.completedEffectIds ? [...state.completedEffectIds] : [],
+        processedIdempotencyKeys: state.processedIdempotencyKeys
+            ? [...state.processedIdempotencyKeys]
+            : [],
+    };
+}
+function completeEffect(state, effectId) {
+    const completed = state.completedEffectIds ?? [];
+    return {
+        ...state,
+        outstandingEffects: state.outstandingEffects.filter((item) => item.effectId !== effectId),
+        completedEffectIds: completed.includes(effectId) ? completed : [...completed, effectId],
+    };
+}
+function putThread(state, record) {
+    return {
+        ...state,
+        threads: { ...state.threads, [record.threadId]: record },
+    };
+}
+function addWait(state, record) {
+    return {
+        ...state,
+        waits: { ...state.waits, [record.waitId]: record },
+    };
+}
+function removeWait(state, waitId) {
+    const { [waitId]: _removed, ...rest } = state.waits;
+    return { ...state, waits: rest };
+}
+function threadWaits(state, threadId) {
+    return Object.values(state.waits).filter((record) => record.threadId === threadId);
+}
+function dropThreadWork(state, threadId) {
+    const waits = {};
+    for (const [waitId, record] of Object.entries(state.waits)) {
+        if (record.threadId !== threadId) {
+            waits[waitId] = record;
+        }
+    }
+    return {
+        ...state,
+        waits,
+        outstandingEffects: state.outstandingEffects.filter((item) => item.threadId !== threadId),
+    };
+}
+function applyProtocol(state, event, registry) {
+    const payload = payloadObject(event);
+    switch (event.type) {
+        case 'runtime.run.started': {
+            const rootThreadId = readString(payload, 'rootThreadId') ?? null;
+            return { ...state, runId: event.runId, rootThreadId, status: 'running' };
+        }
+        case 'runtime.run.completed': {
+            const error = payload.error;
+            const status = Predicate.isString(error) && error.length > 0 ? 'failed' : 'completed';
+            return { ...state, status };
+        }
+        case 'runtime.thread.started': {
+            const threadId = readString(payload, 'threadId') ?? event.threadId;
+            const kind = readString(payload, 'kind');
+            const definitionName = readString(payload, 'definitionName');
+            if (!threadId || !kind || !definitionName) {
+                return state;
+            }
+            const parent = payload.parentThreadId;
+            const parentThreadId = parent === null || Predicate.isString(parent) ? parent : null;
+            const input = payload.input ?? null;
+            const definition = registry.threads.get(kind);
+            const record = {
+                threadId,
+                kind,
+                definitionName,
+                parentThreadId,
+                status: definition ? 'running' : 'failed',
+                input,
+                output: null,
+                error: definition ? null : `Unsupported thread kind: ${kind}`,
+                state: definition
+                    ? definition.initialState({
+                        runId: event.runId,
+                        threadId,
+                        parentThreadId,
+                        definitionName,
+                        input,
+                    })
+                    : {},
+            };
+            let next = putThread(state, record);
+            if (!next.rootThreadId) {
+                next = { ...next, rootThreadId: threadId };
+            }
+            return next;
+        }
+        case 'runtime.thread.completed': {
+            const threadId = readString(payload, 'threadId') ?? event.threadId;
+            if (!threadId) {
+                return state;
+            }
+            const existing = state.threads[threadId];
+            if (!existing) {
+                return state;
+            }
+            return putThread(state, {
+                ...existing,
+                status: 'completed',
+                output: payload.output ?? null,
+                error: null,
+            });
+        }
+        case 'runtime.thread.failed': {
+            const threadId = readString(payload, 'threadId') ?? event.threadId;
+            if (!threadId) {
+                return state;
+            }
+            const existing = state.threads[threadId];
+            if (!existing) {
+                return state;
+            }
+            return dropThreadWork(putThread(state, {
+                ...existing,
+                status: 'failed',
+                error: readString(payload, 'error') ?? 'failed',
+            }), threadId);
+        }
+        case 'runtime.thread.cancelled': {
+            const threadId = readString(payload, 'threadId') ?? event.threadId;
+            if (!threadId) {
+                return state;
+            }
+            const existing = state.threads[threadId];
+            if (!existing) {
+                return state;
+            }
+            return dropThreadWork(putThread(state, {
+                ...existing,
+                status: 'cancelled',
+                error: readString(payload, 'reason') ?? existing.error,
+            }), threadId);
+        }
+        case 'runtime.wait.registered': {
+            const waitId = readString(payload, 'waitId');
+            const threadId = readString(payload, 'threadId') ?? event.threadId;
+            const on = payload.on;
+            if (!waitId || !threadId || !on || !Predicate.isObject(on)) {
+                return state;
+            }
+            // SAFETY: wait.registered payload.on is a WaitCondition written by the runtime.
+            const record = {
+                waitId,
+                threadId,
+                on: on,
+            };
+            if (payload.tag !== undefined) {
+                record.tag = payload.tag;
+            }
+            let next = addWait(state, record);
+            const existing = next.threads[threadId];
+            if (existing && !isTerminalStatus(existing.status)) {
+                next = putThread(next, { ...existing, status: 'waiting' });
+            }
+            return next;
+        }
+        case 'runtime.wait.satisfied': {
+            const waitId = readString(payload, 'waitId');
+            if (!waitId) {
+                return state;
+            }
+            const existingWait = state.waits[waitId];
+            let next = removeWait(state, waitId);
+            const threadId = existingWait?.threadId ?? event.threadId;
+            if (!threadId) {
+                return next;
+            }
+            const existing = next.threads[threadId];
+            if (existing && existing.status === 'waiting' && threadWaits(next, threadId).length === 0) {
+                next = putThread(next, { ...existing, status: 'running' });
+            }
+            return next;
+        }
+        case 'runtime.snapshot.taken':
+        case 'runtime.timer.set':
+        case 'runtime.timer.fired':
+        case 'runtime.effect.failed':
+        case 'runtime.signal.received':
+            return state;
+        default:
+            return state;
+    }
+}
+function deriveEffectId(threadId, causingSeq, index, effect, existingId) {
+    if ('tag' in effect && Predicate.isString(effect.tag)) {
+        return createEffectId(threadId, effect.tag);
+    }
+    if ('waitId' in effect && Predicate.isString(effect.waitId)) {
+        return createEffectId(threadId, effect.waitId);
+    }
+    if ('childThreadId' in effect && Predicate.isString(effect.childThreadId)) {
+        return createEffectId(threadId, `spawn_${effect.childThreadId}`);
+    }
+    if (existingId) {
+        return existingId;
+    }
+    return createEffectId(threadId, causingSeq, index);
+}
+function mapEffects(threadId, event, effects, completed, existingForThread) {
+    const remainingExisting = [...existingForThread];
+    return effects
+        .map((effect, index) => {
+        const matchIndex = remainingExisting.findIndex((item) => {
+            if ('tag' in effect && Predicate.isString(effect.tag)) {
+                return item.effectId === createEffectId(threadId, effect.tag);
+            }
+            if ('waitId' in effect && Predicate.isString(effect.waitId)) {
+                return item.effectId === createEffectId(threadId, effect.waitId);
+            }
+            if ('childThreadId' in effect && Predicate.isString(effect.childThreadId)) {
+                return item.effectId === createEffectId(threadId, `spawn_${effect.childThreadId}`);
+            }
+            return item.effect.type === effect.type;
+        });
+        const existing = matchIndex >= 0 ? remainingExisting.splice(matchIndex, 1)[0] : undefined;
+        const effectId = deriveEffectId(threadId, event.seq, index, effect, existing?.effectId);
+        return (existing ?? {
+            effectId,
+            threadId,
+            causingSeq: event.seq,
+            causingEventId: event.id,
+            effect,
+        });
+    })
+        .filter((item) => !completed.includes(item.effectId));
+}
+/** Reconcile a thread's outstanding effects with enabled work from `effects()`. */
+function reconcileEffects(state, threadId, event, effects) {
+    const record = state.threads[threadId];
+    if (record && isTerminalStatus(record.status)) {
+        return {
+            ...state,
+            outstandingEffects: state.outstandingEffects.filter((item) => item.threadId !== threadId),
+        };
+    }
+    const completed = state.completedEffectIds ?? [];
+    const existingForThread = state.outstandingEffects.filter((item) => item.threadId === threadId);
+    const mapped = mapEffects(threadId, event, effects, completed, existingForThread);
+    const otherThreadEffects = state.outstandingEffects.filter((item) => item.threadId !== threadId);
+    return {
+        ...state,
+        outstandingEffects: [...otherThreadEffects, ...mapped],
+    };
+}
+function deliver(state, event, registry) {
+    const threadId = event.threadId;
+    if (!threadId) {
+        return state;
+    }
+    const record = state.threads[threadId];
+    if (!record) {
+        return state;
+    }
+    const definition = registry.threads.get(record.kind);
+    if (!definition) {
+        return state;
+    }
+    const ctx = {
+        runId: state.runId,
+        threadId,
+        parentThreadId: record.parentThreadId,
+    };
+    const nextState = definition.step(record.state, event, ctx);
+    const enabled = definition.effects(nextState, ctx);
+    let next = putThread(state, { ...record, state: nextState });
+    next = reconcileEffects(next, threadId, event, enabled);
+    return next;
+}
+function failUnhandledEffect(state, event, effectIdsBeforeDeliver) {
+    if (event.type !== 'runtime.effect.failed') {
+        return state;
+    }
+    const payload = payloadObject(event);
+    const error = readString(payload, 'error') ?? 'effect failed';
+    if (isWithdrawnError(error)) {
+        return state;
+    }
+    const handled = state.outstandingEffects.some((item) => !effectIdsBeforeDeliver.has(item.effectId));
+    if (handled) {
+        return state;
+    }
+    const threadId = event.threadId;
+    if (!threadId) {
+        return state;
+    }
+    const existing = state.threads[threadId];
+    if (!existing || isTerminalStatus(existing.status)) {
+        return state;
+    }
+    return dropThreadWork(putThread(state, {
+        ...existing,
+        status: 'failed',
+        error,
+    }), threadId);
+}
+export function foldEvent(state, event, registry) {
+    if (event.ephemeral) {
+        return state;
+    }
+    let next = cloneState(state);
+    if (event.runId && next.runId !== event.runId) {
+        next = { ...next, runId: event.runId };
+    }
+    if (event.effectId) {
+        next = completeEffect(next, event.effectId);
+    }
+    if (event.idempotencyKey) {
+        const keys = next.processedIdempotencyKeys ?? [];
+        if (!keys.includes(event.idempotencyKey)) {
+            next = { ...next, processedIdempotencyKeys: [...keys, event.idempotencyKey] };
+        }
+    }
+    next = applyProtocol(next, event, registry);
+    const effectIdsBeforeDeliver = new Set(next.outstandingEffects.map((item) => item.effectId));
+    next = deliver(next, event, registry);
+    return failUnhandledEffect(next, event, effectIdsBeforeDeliver);
+}
+export function foldRun(events, registry, options) {
+    const base = options?.initial ? cloneState(options.initial) : emptyRunState(options?.runId ?? '');
+    return events.reduce((acc, event) => foldEvent(acc, event, registry), base);
+}
+/**
+ * Folds an Effect Stream of events into RunState without buffering all events into memory.
+ */
+export function foldStream(stream, registry, options) {
+    const getBase = () => options?.initial ? cloneState(options.initial) : emptyRunState(options?.runId ?? '');
+    return Stream.runFold(stream, getBase, (acc, event) => foldEvent(acc, event, registry));
+}

package/dist/core/ids.d.ts

@@ -0,0 +1,11 @@
+export declare function createEventId(): string;
+export declare function createRunId(): string;
+export declare function createThreadId(): 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): {
+    threadId: string;
+    causingSeq?: number;
+    tag?: string;
+    index?: number;
+} | null;

package/dist/core/ids.js

@@ -0,0 +1,47 @@
+import { 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)}`;
+}
+export function createEventId() {
+    return `evt_${token()}`;
+}
+export function createRunId() {
+    return `run_${token()}`;
+}
+export function createThreadId() {
+    return `thr_${token()}`;
+}
+export function createWaitId(scope, tag) {
+    if (scope !== undefined && tag !== undefined) {
+        return `wait_${scope}_${tag}`;
+    }
+    if (scope !== undefined) {
+        return `wait_${scope}_${token()}`;
+    }
+    return `wait_${token()}`;
+}
+export function createEffectId(threadId, causingSeqOrTag, index) {
+    if (Predicate.isString(causingSeqOrTag)) {
+        return `${threadId}:${causingSeqOrTag}`;
+    }
+    return `${threadId}:${causingSeqOrTag}:${index ?? 0}`;
+}
+export function parseEffectId(effectId) {
+    const parts = effectId.split(':');
+    if (parts.length < 2) {
+        return null;
+    }
+    if (parts.length === 3) {
+        const seq = Number(parts[1]);
+        const idx = Number(parts[2]);
+        if (Number.isFinite(seq) && Number.isFinite(idx)) {
+            return { threadId: parts[0], causingSeq: seq, index: idx };
+        }
+    }
+    return {
+        threadId: parts[0],
+        tag: parts.slice(1).join(':'),
+    };
+}

package/dist/core/index.d.ts

@@ -0,0 +1,26 @@
+export type * from './types';
+export { asJson, cleanUndefined, fromJsonStruct, isJsonNumber, isJsonObject, isJsonString, } from './types';
+export * from './ids';
+export * from './schema';
+export * from './validate-event';
+export * from './envelope';
+export * from './catalog';
+export * from './effects';
+export * from './protocol';
+export * from './thread';
+export * from './state';
+export * from './match';
+export * from './fold';
+export * from './replay';
+export * from './projection';
+export * from './module';
+export * from './module-scope';
+export * from './compose';
+export * from './store';
+export * from './cursor';
+export * from './snapshot-store';
+export * from './snapshots';
+export * from './event-codec';
+export * from './serialize';
+export * from './coalesce';
+export * from './event-index';

package/dist/core/index.js

@@ -0,0 +1,25 @@
+export { asJson, cleanUndefined, fromJsonStruct, isJsonNumber, isJsonObject, isJsonString, } from './types.js';
+export * from './ids.js';
+export * from './schema.js';
+export * from './validate-event.js';
+export * from './envelope.js';
+export * from './catalog.js';
+export * from './effects.js';
+export * from './protocol.js';
+export * from './thread.js';
+export * from './state.js';
+export * from './match.js';
+export * from './fold.js';
+export * from './replay.js';
+export * from './projection.js';
+export * from './module.js';
+export * from './module-scope.js';
+export * from './compose.js';
+export * from './store.js';
+export * from './cursor.js';
+export * from './snapshot-store.js';
+export * from './snapshots.js';
+export * from './event-codec.js';
+export * from './serialize.js';
+export * from './coalesce.js';
+export * from './event-index.js';

package/dist/core/match.d.ts

@@ -0,0 +1,8 @@
+import { type WaitCondition } from './effects';
+import type { EventEnvelope } from './envelope';
+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 {
+    on: WaitCondition;
+}>(event: EventEnvelope, waits: readonly T[]): T[];

package/dist/core/match.js

@@ -0,0 +1,58 @@
+import { Predicate } from 'effect';
+import { isWaitOnEvent, isWaitOnTimer } from './effects.js';
+export function isSubset(match, payload) {
+    if (match === payload) {
+        return true;
+    }
+    if (Array.isArray(match)) {
+        if (!Array.isArray(payload)) {
+            return false;
+        }
+        if (match.length !== payload.length) {
+            return false;
+        }
+        return match.every((item, index) => isSubset(item, payload[index] ?? null));
+    }
+    if (Predicate.isReadonlyObject(match)) {
+        if (!Predicate.isObject(payload)) {
+            return false;
+        }
+        for (const key of Object.keys(match)) {
+            const expected = match[key];
+            if (expected === undefined) {
+                continue;
+            }
+            if (!(key in payload)) {
+                return false;
+            }
+            const actual = payload[key];
+            if (actual === undefined) {
+                return false;
+            }
+            if (!isSubset(expected, actual)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+export function matchesWait(event, on) {
+    if (isWaitOnTimer(on)) {
+        return event.type === 'runtime.timer.fired';
+    }
+    if (!isWaitOnEvent(on)) {
+        return false;
+    }
+    const matchesType = Array.isArray(on.type) ? on.type.includes(event.type) : event.type === on.type;
+    if (!matchesType) {
+        return false;
+    }
+    if (on.match === undefined) {
+        return true;
+    }
+    return isSubset(on.match, event.payload);
+}
+export function matchingWaits(event, waits) {
+    return waits.filter((record) => matchesWait(event, record.on));
+}

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

@@ -0,0 +1,99 @@
+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 { EventEnvelope, EventInput } from './envelope';
+import { type AnyRuntimeModule, type EffectMiddleware, type RuntimeModule, type DefinitionRef, type RuntimeModuleDependency } from './module';
+import { type ProjectionDefinition } from './projection';
+import type { InferDefinedSchema, InferSchemaOutput, SchemaInput } from './schema';
+import { type StartContext, type ThreadContext, type ThreadDefinition } from './thread';
+import { type JsonValue } from './types';
+export interface DefineModuleOptions<TNamespace extends string, TEvents extends EventCatalog | undefined = undefined, TObserves extends readonly EventCatalog[] | undefined = undefined> {
+    readonly namespace: TNamespace;
+    readonly protocolVersion: string;
+    readonly events?: TEvents;
+    readonly observes?: TObserves;
+    readonly dependencies?: readonly RuntimeModuleDependency[];
+}
+export type ScopeUniverse<TEvents extends EventCatalog | undefined, TObserves extends readonly EventCatalog[] | undefined> = ProtocolEvents | (TEvents extends EventCatalog ? EventsOfCatalog<TEvents> : never) | (TObserves extends readonly EventCatalog[] ? EventsOfCatalog<TObserves[number]> : never);
+export type EffectRequirementsOf<TEffects> = TEffects extends {
+    readonly [key: string]: EffectDefinition<any, any, any>;
+} ? {
+    [K in keyof TEffects]: TEffects[K] extends EffectDefinition<any, infer R, any> ? R : never;
+}[keyof TEffects] : never;
+export type ModuleServicesConfig<TR> = [TR] extends [never] ? {
+    readonly services?: () => Layer.Layer<any>;
+} : {
+    readonly services: () => Layer.Layer<TR>;
+};
+export interface ModuleScope<TNamespace extends string, U extends EventEnvelope<any, any>, TEvents extends EventCatalog | undefined, TObserves extends readonly EventCatalog[] | undefined = readonly EventCatalog[] | undefined> {
+    readonly namespace: TNamespace;
+    readonly protocolVersion: string;
+    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 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;
+        readonly shape: TShape;
+        readonly initialState: InferSchemaOutput<TShape>;
+        reduce(state: InferSchemaOutput<TShape>, event: U): InferSchemaOutput<TShape>;
+    }): ProjectionDefinition<InferSchemaOutput<TShape>>;
+    projection<S>(def: {
+        readonly name: string;
+        readonly shape?: unknown;
+        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: {
+        type: `${TNamespace}.${string}`;
+        input?: TSchema;
+        retry?: RetryPolicy;
+        execute: (input: TInput, ctx: ScopedEffectContext<EventInputOf<U>>) => EffectHandlerResult<R, EventInputOf<U>>;
+    }): NoInfer<EffectDefinition<TInput, R, E>>;
+    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]>;
+    };
+    emit<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'>): EmitEffect;
+}
+export type EventOf<T> = T extends ModuleScope<any, infer U, any> ? U : T extends AnyRuntimeModule ? EventsOf<T> : never;
+export type ThreadStateOf<T> = T extends ThreadDefinition<infer S> ? S : never;
+export declare function createModuleScope<TNamespace extends string, TEvents extends EventCatalog | undefined = undefined, TObserves extends readonly EventCatalog[] | undefined = undefined>(options: DefineModuleOptions<TNamespace, TEvents, TObserves>): ModuleScope<TNamespace, ScopeUniverse<TEvents, TObserves>, TEvents, TObserves>;
+/** A catalog may be supplied directly, or created from inline event schemas. */
+export type ModuleCatalog<N extends string, E> = E extends EventCatalog ? E : E extends CatalogEntries ? EventCatalog<N, E> : undefined;
+/** Construct a complete module. Only members returned by setup are installed. */
+export declare function defineModule<const N extends string, E extends EventCatalog | CatalogEntries | undefined = undefined, O extends readonly EventCatalog[] | undefined = undefined, FX extends {
+    readonly [key: string]: EffectDefinition<any, any, any>;
+} = {}, TH extends {
+    readonly [key: string]: ThreadDefinition;
+} = {}, PR extends {
+    readonly [key: string]: ProjectionDefinition;
+} = {}>(options: Omit<DefineModuleOptions<N, ModuleCatalog<N, E>, O>, 'events'> & {
+    readonly events?: E;
+}, setup: (scope: ModuleScope<N, ScopeUniverse<ModuleCatalog<N, E>, O>, ModuleCatalog<N, E>, O>) => {
+    readonly effects?: FX;
+    readonly threads?: TH;
+    readonly projections?: PR;
+    readonly definitions?: readonly DefinitionRef[];
+    readonly middleware?: readonly EffectMiddleware[];
+} & ModuleServicesConfig<EffectRequirementsOf<FX>>): RuntimeModule<N, Extract<ModuleCatalog<N, E>, EventCatalog>, FX, TH, PR> & {
+    readonly effects: FX;
+    readonly threads: TH;
+    readonly projections: PR;
+};