@swirls/looms 0.3.0 → 0.4.0

package/dist/core/attempts.d.ts

@@ -0,0 +1,8 @@
+import type { AnyEventEnvelope } from './register';
+/** The effect a `runtime.effect.retry.scheduled` event retries, or `undefined` for other events. */
+export declare function retriedEffectId(event: AnyEventEnvelope): string | undefined;
+/**
+ * Drops ephemeral events from effect attempts that a later retry in `events` superseded. Durable
+ * events and ephemeral events from the current attempt are kept.
+ */
+export declare function dropSupersededAttempts<E extends AnyEventEnvelope>(events: readonly E[]): readonly E[];

package/dist/core/attempts.js

@@ -0,0 +1,27 @@
+import { Schema } from 'effect';
+import { protocolCatalog } from './protocol.js';
+const RETRY_SCHEDULED = 'runtime.effect.retry.scheduled';
+const isRetryPayload = Schema.is(protocolCatalog.entries['effect.retry.scheduled']);
+/** The effect a `runtime.effect.retry.scheduled` event retries, or `undefined` for other events. */
+export function retriedEffectId(event) {
+    return event.type === RETRY_SCHEDULED && isRetryPayload(event.payload)
+        ? event.payload.effectId
+        : undefined;
+}
+/**
+ * Drops ephemeral events from effect attempts that a later retry in `events` superseded. Durable
+ * events and ephemeral events from the current attempt are kept.
+ */
+export function dropSupersededAttempts(events) {
+    const lastRetry = new Map();
+    events.forEach((event, index) => {
+        const effectId = retriedEffectId(event);
+        if (effectId !== undefined) {
+            lastRetry.set(effectId, index);
+        }
+    });
+    if (lastRetry.size === 0) {
+        return events;
+    }
+    return events.filter((event, index) => !event.ephemeral || !event.effectId || (lastRetry.get(event.effectId) ?? -1) < index);
+}

package/dist/core/index.d.ts

@@ -15,6 +15,8 @@ export * from './fold';
 export * from './replay';
 export * from './fork';
 export * from './projection';
+export * from './attempts';
+export type * from './register';
 export * from './module';
 export * from './kind';
 export * from './module-scope';

package/dist/core/index.js

@@ -14,6 +14,7 @@ export * from './fold.js';
 export * from './replay.js';
 export * from './fork.js';
 export * from './projection.js';
+export * from './attempts.js';
 export * from './module.js';
 export * from './kind.js';
 export * from './module-scope.js';

package/dist/core/projection.d.ts

@@ -1,5 +1,6 @@
 import { Schema, Stream, type Effect } from 'effect';
 import type { EventEnvelope } from './envelope';
+import type { AnyEventEnvelope, RegisteredEvent } from './register';
 import type { InferSchemaOutput, SchemaInput } from './schema';
 import type { RunState, ThreadRecord } from './state';
 export interface ProjectionDefinition<S = unknown> {
@@ -8,17 +9,17 @@ export interface ProjectionDefinition<S = unknown> {
     initialState: S;
     reduce(state: S, event: EventEnvelope): S;
 }
-export declare function defineProjection<S = unknown>(def: {
+export declare function defineProjection<S = unknown, TEvent extends AnyEventEnvelope = RegisteredEvent>(def: {
     readonly name: string;
     readonly shape?: undefined;
     readonly initialState: S;
-    reduce(state: S, event: EventEnvelope): S;
+    reduce(state: S, event: TEvent): S;
 }): ProjectionDefinition<S>;
-export declare function defineProjection<TShape extends SchemaInput>(def: {
+export declare function defineProjection<TShape extends SchemaInput, TEvent extends AnyEventEnvelope = RegisteredEvent>(def: {
     readonly name: string;
     readonly shape: TShape;
     readonly initialState: InferSchemaOutput<TShape>;
-    reduce(state: NoInfer<InferSchemaOutput<TShape>>, event: EventEnvelope): InferSchemaOutput<TShape>;
+    reduce(state: NoInfer<InferSchemaOutput<TShape>>, event: TEvent): 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. */

package/dist/{react → core}/register.d.ts

@@ -1,11 +1,12 @@
-import type { EventEnvelope, EventsOf } from '@swirls/looms/core';
+import type { EventsOf } from './compose';
+import type { EventEnvelope } from './envelope';
 /** Looser event bound so catalog-inferred payloads (including Schema.Type) are accepted. */
 export type AnyEventEnvelope = EventEnvelope<string, any>;
 /**
- * Application-level type registry for Looms React/client stores.
+ * Application-level type registry for Looms.
  *
- * Augment this interface in your app to bind the event catalog used by
- * `useRunEvents`, `createLoomsStore`, and related hooks:
+ * Augment this interface once to bind your event union. `defineProjection` reducers and the
+ * `@swirls/looms/react` hooks and stores use it as their default event type:
  *
  * ```ts
  * declare module '@swirls/looms/react' {
@@ -15,7 +16,7 @@ export type AnyEventEnvelope = EventEnvelope<string, any>;
  * }
  * ```
  *
- * You may register either:
+ * Augmenting `@swirls/looms/core` works the same way. You may register either:
  * - `events`: an explicit event union
  * - `modules`: a module array / creator function (via `EventsOf`)
  * - `catalog`: an event catalog or catalog array (via `EventsOf`)
@@ -24,8 +25,8 @@ export interface LoomsRegister {
 }
 export type RegisteredEvent = LoomsRegister extends {
     events: infer E;
-} ? E & AnyEventEnvelope : LoomsRegister extends {
+} ? Extract<E, AnyEventEnvelope> : LoomsRegister extends {
     modules: infer M;
-} ? EventsOf<M> & AnyEventEnvelope : LoomsRegister extends {
+} ? Extract<EventsOf<M>, AnyEventEnvelope> : LoomsRegister extends {
     catalog: infer C;
-} ? EventsOf<C> & AnyEventEnvelope : EventEnvelope;
+} ? Extract<EventsOf<C>, AnyEventEnvelope> : EventEnvelope;