@swirls/looms 0.0.2 → 0.2.0

package/dist/core/projection.js

@@ -1,4 +1,5 @@
 import { Predicate, Schema, Stream } from 'effect';
+import { DEFAULT_DEFINITION_VERSION } from './module.js';
 import { isTerminalStatus } from './thread.js';
 export function defineProjection(def) {
     return def;
@@ -26,8 +27,6 @@ export function projectStream(definition, stream, from) {
     const getInitial = () => (from !== undefined ? from : definition.initialState);
     return Stream.runFold(stream, getInitial, (state, event) => event.ephemeral ? state : definition.reduce(state, event));
 }
-// SAFETY: TreeBuildState is folded by reducers; Schema.Unknown is a typed placeholder, not a decoder.
-export const TreeBuildStateSchema = Schema.Unknown;
 function readPayload(event) {
     if (!Predicate.isObject(event.payload)) {
         return {};
@@ -40,7 +39,6 @@ function readString(obj, key) {
 }
 export const threadTree = defineProjection({
     name: 'threadTree',
-    shape: TreeBuildStateSchema,
     initialState: { runId: '', records: {}, rootThreadId: null },
     reduce(state, event) {
         const payload = readPayload(event);
@@ -57,6 +55,7 @@ export const threadTree = defineProjection({
                 const threadId = readString(payload, 'threadId') ?? event.threadId;
                 const kind = readString(payload, 'kind');
                 const definitionName = readString(payload, 'definitionName');
+                const definitionVersion = readString(payload, 'definitionVersion') ?? DEFAULT_DEFINITION_VERSION;
                 if (!threadId || !kind || !definitionName) {
                     return { ...state, runId: event.runId };
                 }
@@ -66,6 +65,7 @@ export const threadTree = defineProjection({
                     threadId,
                     kind,
                     definitionName,
+                    definitionVersion,
                     parentThreadId,
                     status: 'running',
                     input: payload.input ?? null,
@@ -173,10 +173,13 @@ export function toThreadTree(state) {
         runId: state.runId,
         status: 'running',
         rootThreadId: state.rootThreadId,
+        startIdentity: null,
         threads: state.records,
         waits: {},
         outstandingEffects: [],
+        effectExecutions: {},
         completedEffectIds: [],
+        processedIdempotencyKeys: [],
     });
 }
 export function treeFromRun(state) {
@@ -196,6 +199,7 @@ export function treeFromRun(state) {
             threadId: record.threadId,
             kind: record.kind,
             definitionName: record.definitionName,
+            definitionVersion: record.definitionVersion,
             status: isWaiting ? 'waiting' : record.status,
             parentThreadId: record.parentThreadId,
             children: (byParent.get(record.threadId) ?? []).map(toNode),
@@ -210,13 +214,13 @@ export function treeFromRun(state) {
     };
 }
 export const TimelineEntrySchema = Schema.Struct({
-    seq: Schema.Number,
+    seq: Schema.Finite,
     id: Schema.String,
     type: Schema.String,
     threadId: Schema.NullOr(Schema.String),
     causationId: Schema.NullOr(Schema.String),
     effectId: Schema.NullOr(Schema.String),
-    ts: Schema.Number,
+    ts: Schema.Finite,
 });
 export const TimelineSchema = Schema.mutable(Schema.Array(TimelineEntrySchema));
 export const timeline = defineProjection({

package/dist/core/protocol.d.ts

@@ -1,27 +1,27 @@
 import { Schema } from 'effect';
 import { type EventInputOf, type EventsOfCatalog } from './catalog';
-import type { WaitCondition } from './effects';
-export declare const WaitConditionSchema: Schema.Union<readonly [Schema.Struct<{
-    readonly type: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
-    readonly match: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-}>, Schema.Struct<{
-    readonly timerAt: Schema.Number;
-}>]>;
+import { WaitConditionSchema, type WaitCondition } from './effects';
 export declare const protocolCatalog: import("./catalog").EventCatalog<"runtime", {
     'run.started': Schema.Struct<{
         readonly rootThreadId: Schema.optional<Schema.String>;
         readonly kind: Schema.String;
         readonly definitionName: Schema.String;
+        readonly definitionVersion: Schema.withDecodingDefaultKey<Schema.String, never>;
         readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly requestedThreadId: Schema.optional<Schema.NullOr<Schema.String>>;
     }>;
     'run.completed': Schema.Struct<{
         readonly output: Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
         readonly error: Schema.NullOr<Schema.String>;
     }>;
+    'run.cancelled': Schema.Struct<{
+        readonly reason: Schema.optional<Schema.String>;
+    }>;
     'thread.started': Schema.Struct<{
         readonly threadId: Schema.String;
         readonly kind: Schema.String;
         readonly definitionName: Schema.String;
+        readonly definitionVersion: Schema.withDecodingDefaultKey<Schema.String, never>;
         readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
         readonly parentThreadId: Schema.NullOr<Schema.String>;
     }>;
@@ -37,6 +37,9 @@ export declare const protocolCatalog: import("./catalog").EventCatalog<"runtime"
         readonly threadId: Schema.String;
         readonly reason: Schema.optional<Schema.String>;
     }>;
+    'thread.cancel.requested': Schema.Struct<{
+        readonly threadId: Schema.String;
+    }>;
     'wait.registered': Schema.Struct<{
         readonly waitId: Schema.String;
         readonly threadId: Schema.optional<Schema.String>;
@@ -44,7 +47,7 @@ export declare const protocolCatalog: import("./catalog").EventCatalog<"runtime"
             readonly type: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
             readonly match: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
         }>, Schema.Struct<{
-            readonly timerAt: Schema.Number;
+            readonly timerAt: Schema.Finite;
         }>]>;
         readonly tag: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
     }>;
@@ -60,7 +63,7 @@ export declare const protocolCatalog: import("./catalog").EventCatalog<"runtime"
     'timer.set': Schema.Struct<{
         readonly timerId: Schema.String;
         readonly waitId: Schema.String;
-        readonly wakeAt: Schema.Number;
+        readonly wakeAt: Schema.Finite;
     }>;
     'timer.fired': Schema.Struct<{
         readonly timerId: Schema.String;
@@ -70,8 +73,62 @@ export declare const protocolCatalog: import("./catalog").EventCatalog<"runtime"
         readonly effectId: Schema.String;
         readonly error: Schema.String;
     }>;
+    'effect.attempt.started': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+    }>;
+    'effect.queued': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+        readonly deadlineAt: Schema.NullOr<Schema.Finite>;
+    }>;
+    'effect.dispatched': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+        readonly deadlineAt: Schema.NullOr<Schema.Finite>;
+    }>;
+    'effect.worker.started': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+        readonly deadlineAt: Schema.NullOr<Schema.Finite>;
+    }>;
+    'effect.heartbeat': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+        readonly heartbeatAt: Schema.Finite;
+        readonly deadlineAt: Schema.NullOr<Schema.Finite>;
+    }>;
+    'effect.cancel.requested': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+        readonly deadlineAt: Schema.NullOr<Schema.Finite>;
+    }>;
+    'effect.cancelled': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+    }>;
+    'effect.completed': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+    }>;
+    'effect.timed_out': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+        readonly timeout: Schema.String;
+    }>;
+    'effect.ambiguous': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+        readonly error: Schema.String;
+    }>;
+    'effect.retry.scheduled': Schema.Struct<{
+        readonly effectId: Schema.String;
+        readonly attempt: Schema.Finite;
+        readonly nextAttemptAt: Schema.Finite;
+        readonly error: Schema.String;
+    }>;
     'snapshot.taken': Schema.Struct<{
-        readonly seq: Schema.Number;
+        readonly seq: Schema.Finite;
         readonly stateHash: Schema.String;
         readonly state: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
     }>;
@@ -81,7 +138,7 @@ export declare const protocolCatalog: import("./catalog").EventCatalog<"runtime"
 }>;
 export type ProtocolEvent = EventsOfCatalog<typeof protocolCatalog>;
 export type ProtocolEventInput = EventInputOf<typeof protocolCatalog>;
-export declare const PROTOCOL_TYPES: readonly ['runtime.run.started', 'runtime.run.completed', 'runtime.thread.started', 'runtime.thread.completed', 'runtime.thread.failed', 'runtime.thread.cancelled', 'runtime.wait.registered', 'runtime.wait.satisfied', 'runtime.timer.set', 'runtime.timer.fired', 'runtime.effect.failed', 'runtime.snapshot.taken', 'runtime.signal.received'];
+export declare const PROTOCOL_TYPES: readonly ['runtime.run.started', 'runtime.run.completed', 'runtime.run.cancelled', 'runtime.thread.started', 'runtime.thread.completed', 'runtime.thread.failed', 'runtime.thread.cancelled', 'runtime.thread.cancel.requested', 'runtime.wait.registered', 'runtime.wait.satisfied', 'runtime.timer.set', 'runtime.timer.fired', 'runtime.effect.failed', 'runtime.effect.attempt.started', 'runtime.effect.queued', 'runtime.effect.dispatched', 'runtime.effect.worker.started', 'runtime.effect.heartbeat', 'runtime.effect.cancel.requested', 'runtime.effect.cancelled', 'runtime.effect.completed', 'runtime.effect.timed_out', 'runtime.effect.ambiguous', 'runtime.effect.retry.scheduled', 'runtime.snapshot.taken', 'runtime.signal.received'];
 export type ProtocolEventType = (typeof PROTOCOL_TYPES)[number];
 export declare function isProtocolType(type: string): type is ProtocolEventType;
 export type RunStartedPayload = Schema.Schema.Type<(typeof protocolCatalog.entries)['run.started']>;

package/dist/core/protocol.js

@@ -1,29 +1,30 @@
-import { Schema } from 'effect';
+import { Effect, Schema } from 'effect';
 import { defineEventCatalog } from './catalog.js';
+import { WaitConditionSchema } from './effects.js';
 import { JsonValueSchema } from './envelope.js';
-const WaitOnEventSchema = Schema.Struct({
-    type: Schema.Union([Schema.String, Schema.Array(Schema.String)]),
-    match: Schema.optional(JsonValueSchema),
-});
-const WaitOnTimerSchema = Schema.Struct({
-    timerAt: Schema.Number,
-});
-export const WaitConditionSchema = Schema.Union([WaitOnEventSchema, WaitOnTimerSchema]);
+import { DEFAULT_DEFINITION_VERSION } from './module.js';
+const DefinitionVersionSchema = Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed(DEFAULT_DEFINITION_VERSION)));
 export const protocolCatalog = defineEventCatalog('runtime', {
     'run.started': Schema.Struct({
         rootThreadId: Schema.optional(Schema.String),
         kind: Schema.String,
         definitionName: Schema.String,
+        definitionVersion: DefinitionVersionSchema,
         input: JsonValueSchema,
+        requestedThreadId: Schema.optional(Schema.NullOr(Schema.String)),
     }),
     'run.completed': Schema.Struct({
         output: Schema.NullOr(JsonValueSchema),
         error: Schema.NullOr(Schema.String),
     }),
+    'run.cancelled': Schema.Struct({
+        reason: Schema.optional(Schema.String),
+    }),
     'thread.started': Schema.Struct({
         threadId: Schema.String,
         kind: Schema.String,
         definitionName: Schema.String,
+        definitionVersion: DefinitionVersionSchema,
         input: JsonValueSchema,
         parentThreadId: Schema.NullOr(Schema.String),
     }),
@@ -39,6 +40,9 @@ export const protocolCatalog = defineEventCatalog('runtime', {
         threadId: Schema.String,
         reason: Schema.optional(Schema.String),
     }),
+    'thread.cancel.requested': Schema.Struct({
+        threadId: Schema.String,
+    }),
     'wait.registered': Schema.Struct({
         waitId: Schema.String,
         threadId: Schema.optional(Schema.String),
@@ -57,7 +61,7 @@ export const protocolCatalog = defineEventCatalog('runtime', {
     'timer.set': Schema.Struct({
         timerId: Schema.String,
         waitId: Schema.String,
-        wakeAt: Schema.Number,
+        wakeAt: Schema.Finite,
     }),
     'timer.fired': Schema.Struct({
         timerId: Schema.String,
@@ -67,8 +71,62 @@ export const protocolCatalog = defineEventCatalog('runtime', {
         effectId: Schema.String,
         error: Schema.String,
     }),
+    'effect.attempt.started': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+    }),
+    'effect.queued': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+        deadlineAt: Schema.NullOr(Schema.Finite),
+    }),
+    'effect.dispatched': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+        deadlineAt: Schema.NullOr(Schema.Finite),
+    }),
+    'effect.worker.started': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+        deadlineAt: Schema.NullOr(Schema.Finite),
+    }),
+    'effect.heartbeat': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+        heartbeatAt: Schema.Finite,
+        deadlineAt: Schema.NullOr(Schema.Finite),
+    }),
+    'effect.cancel.requested': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+        deadlineAt: Schema.NullOr(Schema.Finite),
+    }),
+    'effect.cancelled': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+    }),
+    'effect.completed': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+    }),
+    'effect.timed_out': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+        timeout: Schema.String,
+    }),
+    'effect.ambiguous': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+        error: Schema.String,
+    }),
+    'effect.retry.scheduled': Schema.Struct({
+        effectId: Schema.String,
+        attempt: Schema.Finite,
+        nextAttemptAt: Schema.Finite,
+        error: Schema.String,
+    }),
     'snapshot.taken': Schema.Struct({
-        seq: Schema.Number,
+        seq: Schema.Finite,
         stateHash: Schema.String,
         state: Schema.optional(JsonValueSchema),
     }),
@@ -79,15 +137,28 @@ export const protocolCatalog = defineEventCatalog('runtime', {
 export const PROTOCOL_TYPES = [
     'runtime.run.started',
     'runtime.run.completed',
+    'runtime.run.cancelled',
     'runtime.thread.started',
     'runtime.thread.completed',
     'runtime.thread.failed',
     'runtime.thread.cancelled',
+    'runtime.thread.cancel.requested',
     'runtime.wait.registered',
     'runtime.wait.satisfied',
     'runtime.timer.set',
     'runtime.timer.fired',
     'runtime.effect.failed',
+    'runtime.effect.attempt.started',
+    'runtime.effect.queued',
+    'runtime.effect.dispatched',
+    'runtime.effect.worker.started',
+    'runtime.effect.heartbeat',
+    'runtime.effect.cancel.requested',
+    'runtime.effect.cancelled',
+    'runtime.effect.completed',
+    'runtime.effect.timed_out',
+    'runtime.effect.ambiguous',
+    'runtime.effect.retry.scheduled',
     'runtime.snapshot.taken',
     'runtime.signal.received',
 ];

package/dist/core/published.d.ts

@@ -0,0 +1,43 @@
+import { Schema } from 'effect';
+import type { RegisteredDefinition } from './module';
+import { type RunState } from './state';
+/** A registered definition as `GET /definitions` publishes it. */
+export declare const PublishedDefinitionSchema: Schema.Struct<{
+    readonly kind: Schema.String;
+    readonly name: Schema.String;
+    readonly version: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    /** JSON Schema derived from the definition's `input`. */
+    readonly inputSchema: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>;
+export type PublishedDefinition = Schema.Schema.Type<typeof PublishedDefinitionSchema>;
+export declare const DefinitionCatalogSchema: Schema.Struct<{
+    readonly definitions: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly name: Schema.String;
+        readonly version: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+        /** JSON Schema derived from the definition's `input`. */
+        readonly inputSchema: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>>;
+    readonly projections: Schema.$Array<Schema.String>;
+}>;
+export type DefinitionCatalog = Schema.Schema.Type<typeof DefinitionCatalogSchema>;
+export declare function publishDefinition(definition: RegisteredDefinition): PublishedDefinition;
+/** A run as `GET /runs/summaries` lists it. */
+export declare const RunSummarySchema: Schema.Struct<{
+    readonly runId: Schema.String;
+    readonly status: Schema.Union<readonly [Schema.Literal<"running">, Schema.Literal<"completed">, Schema.Literal<"failed">, Schema.Literal<"cancelled">]>;
+    readonly kind: Schema.NullOr<Schema.String>;
+    readonly definitionName: Schema.NullOr<Schema.String>;
+}>;
+export type RunSummary = Schema.Schema.Type<typeof RunSummarySchema>;
+export declare function summarizeRun(state: RunState): RunSummary;
+export declare const RunSummariesSchema: Schema.Struct<{
+    readonly runs: Schema.$Array<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly status: Schema.Union<readonly [Schema.Literal<"running">, Schema.Literal<"completed">, Schema.Literal<"failed">, Schema.Literal<"cancelled">]>;
+        readonly kind: Schema.NullOr<Schema.String>;
+        readonly definitionName: Schema.NullOr<Schema.String>;
+    }>>;
+}>;

package/dist/core/published.js

@@ -0,0 +1,44 @@
+import { Schema } from 'effect';
+import { JsonValueSchema } from './envelope.js';
+import { jsonSchemaOfInput } from './schema.js';
+import { RunStateSchema } from './state.js';
+/** A registered definition as `GET /definitions` publishes it. */
+export const PublishedDefinitionSchema = Schema.Struct({
+    kind: Schema.String,
+    name: Schema.String,
+    version: Schema.String,
+    description: Schema.optional(Schema.String),
+    /** JSON Schema derived from the definition's `input`. */
+    inputSchema: Schema.optional(JsonValueSchema),
+});
+export const DefinitionCatalogSchema = Schema.Struct({
+    definitions: Schema.Array(PublishedDefinitionSchema),
+    projections: Schema.Array(Schema.String),
+});
+export function publishDefinition(definition) {
+    return {
+        kind: definition.kind,
+        name: definition.name,
+        version: definition.version,
+        description: definition.description,
+        inputSchema: jsonSchemaOfInput(definition.input),
+    };
+}
+/** A run as `GET /runs/summaries` lists it. */
+export const RunSummarySchema = Schema.Struct({
+    runId: Schema.String,
+    status: RunStateSchema.fields.status,
+    kind: Schema.NullOr(Schema.String),
+    definitionName: Schema.NullOr(Schema.String),
+});
+export function summarizeRun(state) {
+    return {
+        runId: state.runId,
+        status: state.status,
+        kind: state.startIdentity?.kind ?? null,
+        definitionName: state.startIdentity?.definitionName ?? null,
+    };
+}
+export const RunSummariesSchema = Schema.Struct({
+    runs: Schema.Array(RunSummarySchema),
+});