@swirls/looms 0.4.0 → 0.5.1

package/dist/core/effects.d.ts

@@ -1,6 +1,8 @@
 import { Effect, Schema, type Context } from 'effect';
 import { type EventInput } from './envelope';
+import type { RunAttributes, SecretContext } from './run-context';
 import { type InferDefinedSchema, type InvalidInputError, type SchemaInput } from './schema';
+import type { TraceContext } from './trace';
 import { type JsonValue } from './types';
 export type WaitOnEvent = {
     type: string | readonly string[];
@@ -43,6 +45,21 @@ export type CancelEffect = {
     threadId: string;
     tag?: string;
 };
+export type LaunchEffect = {
+    type: 'runtime.launch';
+    runId: string;
+    kind: string;
+    definitionName: string;
+    definitionVersion: string;
+    input: JsonValue;
+    close: 'terminate' | 'wait';
+    tag?: string;
+};
+export type CancelRunEffect = {
+    type: 'runtime.cancelRun';
+    runId: string;
+    tag?: string;
+};
 export interface RetryPolicy {
     readonly maxAttempts: number;
     readonly backoffMs?: number;
@@ -57,8 +74,10 @@ export type InvokeEffect = {
     type: string;
     input: JsonValue;
     tag?: string;
+    /** Epoch milliseconds. The host waits until this instant before running the effect. */
+    at?: number;
 };
-export type PrimitiveEffect = SpawnEffect | WaitEffect | EmitEffect | CompleteEffect | FailEffect | CancelEffect;
+export type PrimitiveEffect = SpawnEffect | WaitEffect | EmitEffect | CompleteEffect | FailEffect | CancelEffect | LaunchEffect | CancelRunEffect;
 export type RuntimeEffect = PrimitiveEffect | InvokeEffect;
 export declare const WaitConditionSchema: Schema.Union<readonly [Schema.Struct<{
     readonly type: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>;
@@ -101,6 +120,9 @@ export declare const RuntimeEffectSchema: Schema.Union<readonly [Schema.Struct<{
             readonly actorId: Schema.optional<Schema.String>;
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"system">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"run">;
+            readonly runId: Schema.String;
         }>]>>;
         readonly ephemeral: Schema.optional<Schema.Boolean>;
         readonly id: Schema.optional<Schema.String>;
@@ -118,14 +140,30 @@ export declare const RuntimeEffectSchema: Schema.Union<readonly [Schema.Struct<{
     readonly type: Schema.Literal<"runtime.cancel">;
     readonly threadId: Schema.String;
     readonly tag: Schema.optional<Schema.String>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.launch">;
+    readonly runId: 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 close: Schema.withDecodingDefaultKey<Schema.Union<readonly [Schema.Literal<"terminate">, Schema.Literal<"wait">]>, never>;
+    readonly tag: Schema.optional<Schema.String>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"runtime.cancelRun">;
+    readonly runId: Schema.String;
+    readonly tag: Schema.optional<Schema.String>;
 }>, Schema.Struct<{
     readonly type: Schema.String;
     readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
     readonly tag: Schema.optional<Schema.String>;
+    readonly at: Schema.optional<Schema.Finite>;
 }>]>;
 export declare function isPrimitiveEffect(effect: RuntimeEffect): effect is PrimitiveEffect;
 export declare function isWaitOnTimer(on: WaitCondition): on is WaitOnTimer;
 export declare function isWaitOnEvent(on: WaitCondition): on is WaitOnEvent;
+/** When a deferred invoke becomes runnable, or undefined for effects that run immediately. */
+export declare function deferredUntil(effect: RuntimeEffect): number | undefined;
 export declare const WITHDRAWN_ERROR_PREFIX = "withdrawn:";
 export declare function withdrawnError(siblingEffectId: string): string;
 export declare function isWithdrawnError(error: string): boolean;
@@ -135,6 +173,12 @@ export interface EffectContext {
     readonly threadId: string;
     readonly causingEventId: string;
     readonly signal: AbortSignal;
+    /** Labels safe for every reader of the run. */
+    readonly attributes: RunAttributes;
+    /** Bearer material for this run. Never copy it into an emitted event. */
+    readonly secrets: SecretContext;
+    /** The W3C trace context of the caller that started the run, to parent spans the handler starts. */
+    readonly trace: TraceContext | null;
     emit(event: EventInput): Promise<void>;
 }
 export interface ScopedEffectContext<E extends EventInput = EventInput> {
@@ -143,6 +187,9 @@ export interface ScopedEffectContext<E extends EventInput = EventInput> {
     readonly threadId: string;
     readonly causingEventId: string;
     readonly signal: AbortSignal;
+    readonly attributes: RunAttributes;
+    readonly secrets: SecretContext;
+    readonly trace: TraceContext | null;
     emit(event: E): Promise<void>;
 }
 export type EffectInputSchema = SchemaInput;
@@ -155,6 +202,28 @@ export declare class EffectHandlerError extends EffectHandlerError_base<{
 }> {
     constructor(cause: unknown);
 }
+export interface EffectFailureOptions {
+    readonly error: string;
+    /** Fail the attempt even when the retry policy has attempts remaining. */
+    readonly nonRetryable?: boolean;
+    /** Wait at least this long before the next attempt. Does not shorten the policy backoff. */
+    readonly retryAfterMs?: number;
+}
+declare const EffectFailure_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: "EffectFailure";
+} & Readonly<A>;
+/** A handler's deliberate attempt failure, distinct from an unexpected thrown error. */
+export declare class EffectFailure extends EffectFailure_base<{
+    readonly error: string;
+    readonly nonRetryable: boolean;
+    readonly retryAfterMs?: number;
+}> {
+    constructor(options: EffectFailureOptions);
+}
+/** Fail the current attempt. The retry policy decides whether another attempt is scheduled. */
+export declare function failEffect(options: EffectFailureOptions): Effect.Effect<never, EffectFailure>;
+/** Unwrap a handler failure, including one wrapped by `EffectHandlerError`. */
+export declare function readEffectFailure(cause: unknown): EffectFailure | null;
 export type EffectHandlerResult<R = never, E extends EventInput = EventInput, HandlerError = never> = ReadonlyArray<E> | Promise<ReadonlyArray<E>> | Effect.Effect<ReadonlyArray<E>, HandlerError, R>;
 declare const effectInputType: unique symbol;
 export type EffectExecution = 'local' | 'worker';
@@ -224,6 +293,20 @@ export declare function emit<E extends EventInput = EventInput>(event: E, tag?:
 export declare function complete(output: JsonValue): CompleteEffect;
 export declare function fail(error: string): FailEffect;
 export declare function cancel(threadId: string, tag?: string): CancelEffect;
-export declare function invoke<TInput>(definition: EffectDefinition<TInput, any, any>, input: TInput, tag?: string): InvokeEffect;
-export declare function invoke(type: string, input: JsonValue, tag?: string): InvokeEffect;
+export declare function launch(args: {
+    runId: string;
+    kind: string;
+    definitionName: string;
+    definitionVersion?: string;
+    input: JsonValue;
+    close?: 'terminate' | 'wait';
+    tag?: string;
+}): LaunchEffect;
+export declare function cancelRun(runId: string, tag?: string): CancelRunEffect;
+export interface InvokeOptions {
+    /** Wait until this epoch millisecond before the host runs the effect. */
+    readonly at?: number;
+}
+export declare function invoke<TInput>(definition: EffectDefinition<TInput, any, any>, input: TInput, tag?: string, options?: InvokeOptions): InvokeEffect;
+export declare function invoke(type: string, input: JsonValue, tag?: string, options?: InvokeOptions): InvokeEffect;
 export {};

package/dist/core/effects.js

@@ -43,10 +43,26 @@ export const RuntimeEffectSchema = Schema.Union([
         threadId: Schema.String,
         tag: Schema.optional(Schema.String),
     }),
+    Schema.Struct({
+        type: Schema.Literal('runtime.launch'),
+        runId: Schema.String,
+        kind: Schema.String,
+        definitionName: Schema.String,
+        definitionVersion: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed(DEFAULT_DEFINITION_VERSION))),
+        input: Schema.Json,
+        close: Schema.Union([Schema.Literal('terminate'), Schema.Literal('wait')]).pipe(Schema.withDecodingDefaultKey(Effect.succeed('terminate'))),
+        tag: Schema.optional(Schema.String),
+    }),
+    Schema.Struct({
+        type: Schema.Literal('runtime.cancelRun'),
+        runId: Schema.String,
+        tag: Schema.optional(Schema.String),
+    }),
     Schema.Struct({
         type: Schema.String,
         input: Schema.Json,
         tag: Schema.optional(Schema.String),
+        at: Schema.optional(Schema.Finite),
     }),
 ]);
 export function isPrimitiveEffect(effect) {
@@ -57,6 +73,8 @@ export function isPrimitiveEffect(effect) {
         case 'runtime.complete':
         case 'runtime.fail':
         case 'runtime.cancel':
+        case 'runtime.launch':
+        case 'runtime.cancelRun':
             return true;
         default:
             return false;
@@ -68,6 +86,13 @@ export function isWaitOnTimer(on) {
 export function isWaitOnEvent(on) {
     return 'type' in on;
 }
+/** When a deferred invoke becomes runnable, or undefined for effects that run immediately. */
+export function deferredUntil(effect) {
+    if (isPrimitiveEffect(effect) || effect.at === undefined) {
+        return undefined;
+    }
+    return effect.at;
+}
 export const WITHDRAWN_ERROR_PREFIX = 'withdrawn:';
 export function withdrawnError(siblingEffectId) {
     return `${WITHDRAWN_ERROR_PREFIX} sibling effect ${siblingEffectId} failed`;
@@ -84,6 +109,34 @@ export class EffectHandlerError extends Data.TaggedError('EffectHandlerError') {
         this.name = 'EffectHandlerError';
     }
 }
+/** A handler's deliberate attempt failure, distinct from an unexpected thrown error. */
+export class EffectFailure extends Data.TaggedError('EffectFailure') {
+    constructor(options) {
+        const error = options.error;
+        const nonRetryable = options.nonRetryable === true;
+        if (options.retryAfterMs === undefined) {
+            super({ error, nonRetryable });
+        }
+        else {
+            super({ error, nonRetryable, retryAfterMs: options.retryAfterMs });
+        }
+        this.name = 'EffectFailure';
+    }
+}
+/** Fail the current attempt. The retry policy decides whether another attempt is scheduled. */
+export function failEffect(options) {
+    return Effect.fail(new EffectFailure(options));
+}
+/** Unwrap a handler failure, including one wrapped by `EffectHandlerError`. */
+export function readEffectFailure(cause) {
+    if (cause instanceof EffectFailure) {
+        return cause;
+    }
+    if (cause instanceof EffectHandlerError) {
+        return readEffectFailure(cause.cause);
+    }
+    return null;
+}
 function liftHandlerResult(result) {
     if (Effect.isEffect(result)) {
         return result.pipe(Effect.mapError((cause) => new EffectHandlerError(cause)));
@@ -96,6 +149,14 @@ function liftHandlerResult(result) {
     }
     return Effect.succeed(result);
 }
+function invokeHandler(handler, input, ctx) {
+    try {
+        return liftHandlerResult(handler(input, ctx));
+    }
+    catch (cause) {
+        return Effect.fail(new EffectHandlerError(cause));
+    }
+}
 export function defineEffect(def) {
     const schema = def.input;
     const handler = def.execute;
@@ -109,7 +170,11 @@ export function defineEffect(def) {
         deterministic: def.deterministic,
         execute: (raw, ctx) => Effect.gen(function* () {
             const input = schema ? yield* validateInputEffect(schema, raw) : raw;
-            return handler ? yield* liftHandlerResult(handler(input, ctx)) : noOutput;
+            if (!handler) {
+                return noOutput;
+            }
+            // invokeHandler turns a synchronous throw into EffectHandlerError.
+            return yield* invokeHandler(handler, input, ctx);
         }),
     };
 }
@@ -165,8 +230,39 @@ export function cancel(threadId, tag) {
         ? { type: 'runtime.cancel', threadId }
         : { type: 'runtime.cancel', threadId, tag };
 }
-export function invoke(typeOrDef, input, tag) {
+export function launch(args) {
+    const effect = {
+        type: 'runtime.launch',
+        runId: args.runId,
+        kind: args.kind,
+        definitionName: args.definitionName,
+        definitionVersion: args.definitionVersion ?? DEFAULT_DEFINITION_VERSION,
+        input: args.input,
+        close: args.close ?? 'terminate',
+    };
+    if (args.tag !== undefined) {
+        effect.tag = args.tag;
+    }
+    return effect;
+}
+export function cancelRun(runId, tag) {
+    return tag === undefined
+        ? { type: 'runtime.cancelRun', runId }
+        : { type: 'runtime.cancelRun', runId, tag };
+}
+export function invoke(typeOrDef, input, tag, options) {
     const type = Predicate.isString(typeOrDef) ? typeOrDef : typeOrDef.type;
     const jsonInput = asJson(input);
-    return tag !== undefined ? { type, input: jsonInput, tag } : { type, input: jsonInput };
+    const at = options?.at;
+    if (at !== undefined && !Number.isFinite(at)) {
+        throw new Error('invoke at must be a finite epoch timestamp');
+    }
+    const effect = { type, input: jsonInput };
+    if (tag !== undefined) {
+        effect.tag = tag;
+    }
+    if (at !== undefined) {
+        effect.at = at;
+    }
+    return effect;
 }

package/dist/core/envelope.d.ts

@@ -9,6 +9,9 @@ export declare const EventOriginSchema: Schema.Union<readonly [Schema.Struct<{
     readonly actorId: Schema.optional<Schema.String>;
 }>, Schema.Struct<{
     readonly type: Schema.Literal<"system">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"run">;
+    readonly runId: Schema.String;
 }>]>;
 export type EventOrigin = Schema.Schema.Type<typeof EventOriginSchema>;
 export declare const EventEnvelopeSchema: Schema.Struct<{
@@ -31,6 +34,9 @@ export declare const EventEnvelopeSchema: Schema.Struct<{
         readonly actorId: Schema.optional<Schema.String>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"system">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"run">;
+        readonly runId: Schema.String;
     }>]>;
     readonly ephemeral: Schema.optional<Schema.Boolean>;
     readonly idempotencyKey: Schema.optional<Schema.NullOr<Schema.String>>;
@@ -51,6 +57,9 @@ export declare const EventInputSchema: Schema.Struct<{
         readonly actorId: Schema.optional<Schema.String>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"system">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"run">;
+        readonly runId: Schema.String;
     }>]>>;
     readonly ephemeral: Schema.optional<Schema.Boolean>;
     readonly id: Schema.optional<Schema.String>;

package/dist/core/envelope.js

@@ -14,6 +14,10 @@ export const EventOriginSchema = Schema.Union([
     Schema.Struct({
         type: Schema.Literal('system'),
     }),
+    Schema.Struct({
+        type: Schema.Literal('run'),
+        runId: Schema.String,
+    }),
 ]);
 export const EventEnvelopeSchema = Schema.Struct({
     id: Schema.String,

package/dist/core/event-codec.js

@@ -37,6 +37,9 @@ function readOrigin(raw) {
         const actorId = 'actorId' in raw && Predicate.isString(raw.actorId) ? raw.actorId : undefined;
         return actorId ? { type: 'external', actorId } : { type: 'external' };
     }
+    if ('type' in raw && raw.type === 'run' && 'runId' in raw && Predicate.isString(raw.runId)) {
+        return { type: 'run', runId: raw.runId };
+    }
     return { type: 'system' };
 }
 export function decodeLoomsEvent(raw, runId) {

package/dist/core/fold.js

@@ -1,9 +1,12 @@
 import { Option, Predicate, Schema, Stream } from 'effect';
 import { isWithdrawnError, WaitConditionSchema } from './effects.js';
 import { createEffectId } from './ids.js';
+import { readRunLaunchSource } from './launcher.js';
 import { DEFAULT_DEFINITION_VERSION } from './module.js';
+import { readAttributes } from './run-context.js';
 import { completedRunStatus, emptyRunState } from './state.js';
 import { isTerminalStatus } from './thread.js';
+import { readStoredTrace } from './trace.js';
 const decodeWaitCondition = Schema.decodeUnknownOption(WaitConditionSchema);
 function payloadObject(event) {
     const payload = event.payload;
@@ -19,6 +22,20 @@ function readString(obj, key) {
     const value = obj[key];
     return Predicate.isString(value) ? value : undefined;
 }
+/** Heartbeat progress already recorded for this effect, if any. */
+function priorHeartbeatDetails(state, effectId) {
+    return state.effectExecutions[effectId]?.heartbeatDetails ?? null;
+}
+/**
+ * A heartbeat that carries `details` replaces the saved progress. Every other execution event
+ * keeps it, including the retry that starts the next attempt.
+ */
+function nextHeartbeatDetails(state, effectId, event, payload) {
+    if (event.type === 'runtime.effect.heartbeat' && Object.hasOwn(payload, 'details')) {
+        return payload.details ?? null;
+    }
+    return priorHeartbeatDetails(state, effectId);
+}
 function cloneState(state) {
     return {
         runId: state.runId,
@@ -34,6 +51,10 @@ function cloneState(state) {
         processedIdempotencyKeys: state.processedIdempotencyKeys
             ? [...state.processedIdempotencyKeys]
             : [],
+        launchedRuns: state.launchedRuns ? [...state.launchedRuns] : [],
+        closeWaiting: state.closeWaiting ?? false,
+        childCloseSent: state.childCloseSent ?? false,
+        attributes: state.attributes ?? {},
     };
 }
 function completeEffect(state, effectId) {
@@ -95,6 +116,10 @@ function applyProtocol(state, event, registry) {
                     requestedThreadId: readString(payload, 'requestedThreadId') ?? null,
                     idempotencyKey: event.idempotencyKey ?? null,
                     rootThreadId,
+                    launchedBy: readRunLaunchSource(payload.launchedBy),
+                    correlationId: event.correlationId ?? null,
+                    attributes: readAttributes(payload.attributes),
+                    trace: readStoredTrace(payload.trace),
                 }
                 : null;
             return {
@@ -102,6 +127,7 @@ function applyProtocol(state, event, registry) {
                 runId: event.runId,
                 rootThreadId: rootThreadId ?? null,
                 startIdentity,
+                attributes: startIdentity?.attributes ?? {},
                 status: 'running',
             };
         }
@@ -220,6 +246,7 @@ function applyProtocol(state, event, registry) {
                         deadlineAt: null,
                         startedAt: event.ts,
                         lastHeartbeatAt: null,
+                        heartbeatDetails: priorHeartbeatDetails(state, effectId),
                         lastError: null,
                     },
                 },
@@ -274,6 +301,7 @@ function applyProtocol(state, event, registry) {
                             : sameAttempt
                                 ? previous.lastHeartbeatAt
                                 : null,
+                        heartbeatDetails: nextHeartbeatDetails(state, effectId, event, payload),
                         lastError: readString(payload, 'error') ?? null,
                     },
                 },
@@ -302,6 +330,7 @@ function applyProtocol(state, event, registry) {
                         deadlineAt: nextAttemptAt,
                         startedAt: null,
                         lastHeartbeatAt: null,
+                        heartbeatDetails: priorHeartbeatDetails(state, effectId),
                         lastError: readString(payload, 'error') ?? 'effect failed',
                     },
                 },
@@ -360,6 +389,36 @@ function applyProtocol(state, event, registry) {
             }
             return next;
         }
+        case 'runtime.run.launched': {
+            const childRunId = readString(payload, 'runId');
+            if (!childRunId || state.launchedRuns.some((run) => run.runId === childRunId)) {
+                return state;
+            }
+            const close = readString(payload, 'close');
+            if (close !== 'terminate' && close !== 'wait') {
+                return state;
+            }
+            return {
+                ...state,
+                launchedRuns: [...state.launchedRuns, { runId: childRunId, close }],
+            };
+        }
+        case 'runtime.child.settled': {
+            const childRunId = readString(payload, 'runId');
+            if (!childRunId) {
+                return state;
+            }
+            return {
+                ...state,
+                launchedRuns: state.launchedRuns.filter((run) => run.runId !== childRunId),
+            };
+        }
+        case 'runtime.child.close.requested':
+            return {
+                ...state,
+                childCloseSent: true,
+                closeWaiting: readString(payload, 'policy') === 'wait' ? true : state.closeWaiting,
+            };
         case 'runtime.snapshot.taken':
         case 'runtime.thread.cancel.requested':
         case 'runtime.timer.set':
@@ -388,6 +447,14 @@ export function stableEffectId(threadId, effect) {
         Predicate.isString(effect.threadId)) {
         return createEffectId(threadId, `cancel_${effect.threadId}`);
     }
+    if (effect.type === 'runtime.launch' && 'runId' in effect && Predicate.isString(effect.runId)) {
+        return createEffectId(threadId, `launch_${effect.runId}`);
+    }
+    if (effect.type === 'runtime.cancelRun' &&
+        'runId' in effect &&
+        Predicate.isString(effect.runId)) {
+        return createEffectId(threadId, `cancel_${effect.runId}`);
+    }
     return undefined;
 }
 function mapEffects(threadId, event, effects, completed, existingForThread) {
@@ -427,7 +494,7 @@ function reconcileEffects(state, threadId, event, effects) {
     };
 }
 function deliver(state, event, registry) {
-    const threadId = event.threadId;
+    const threadId = event.threadId ?? (event.origin.type === 'external' ? state.rootThreadId : null);
     if (!threadId) {
         return state;
     }
@@ -451,8 +518,23 @@ function deliver(state, event, registry) {
     const enabled = definition.effects(nextState, ctx);
     let next = putThread(state, { ...record, state: nextState });
     next = reconcileEffects(next, threadId, event, enabled);
+    if (definition.forgetsCompletedEffects) {
+        next = forgetCompletedEffects(next, threadId, enabled);
+    }
     return next;
 }
+/** Drop completed effect ids this thread no longer returns from `effects()`. */
+function forgetCompletedEffects(state, threadId, enabled) {
+    const enabledIds = new Set(enabled.flatMap((effect) => {
+        const effectId = stableEffectId(threadId, effect);
+        return effectId === undefined ? [] : [effectId];
+    }));
+    const prefix = `${threadId}:`;
+    const completedEffectIds = state.completedEffectIds.filter((effectId) => !effectId.startsWith(prefix) || enabledIds.has(effectId));
+    return completedEffectIds.length === state.completedEffectIds.length
+        ? state
+        : { ...state, completedEffectIds };
+}
 function failUnhandledEffect(state, event, effectIdsBeforeDeliver) {
     if (event.type !== 'runtime.effect.failed') {
         return state;

package/dist/core/ids.d.ts

@@ -1,6 +1,8 @@
 export declare function createEventId(): string;
 export declare function createRunId(): string;
 export declare function createThreadId(): string;
+/** A stable `run_` id derived from `parts`, so a retry launches the same child run. */
+export declare function deterministicRunId(...parts: readonly (string | number)[]): string;
 /**
  * A UUID-shaped id derived only from `parts`, so a reducer that replays the same events names the same
  * child thread every time.

package/dist/core/ids.js

@@ -25,6 +25,10 @@ function fnv1a32(value, seed) {
     }
     return (hash >>> 0).toString(16).padStart(8, '0');
 }
+/** A stable `run_` id derived from `parts`, so a retry launches the same child run. */
+export function deterministicRunId(...parts) {
+    return `run_${deterministicThreadId(...parts).replaceAll('-', '')}`;
+}
 /**
  * A UUID-shaped id derived only from `parts`, so a reducer that replays the same events names the same
  * child thread every time.

package/dist/core/index.d.ts

@@ -8,6 +8,7 @@ export * from './envelope';
 export * from './catalog';
 export * from './effects';
 export * from './protocol';
+export * from './subscription';
 export * from './thread';
 export * from './state';
 export * from './match';
@@ -30,6 +31,13 @@ export * from './serialize';
 export * from './coalesce';
 export * from './event-index';
 export * from './limits';
+export * from './blob-store';
+export * from './blobs';
+export * from './blob-offload';
 export * from './definition-store';
+export * from './definition-resolver';
+export * from './launcher';
+export * from './trace';
+export * from './run-context';
 export * from './published';
 export type { DebuggerHost, DebuggerRequest } from './debugger-host';

package/dist/core/index.js

@@ -7,6 +7,7 @@ export * from './envelope.js';
 export * from './catalog.js';
 export * from './effects.js';
 export * from './protocol.js';
+export * from './subscription.js';
 export * from './thread.js';
 export * from './state.js';
 export * from './match.js';
@@ -28,5 +29,12 @@ export * from './serialize.js';
 export * from './coalesce.js';
 export * from './event-index.js';
 export * from './limits.js';
+export * from './blob-store.js';
+export * from './blobs.js';
+export * from './blob-offload.js';
 export * from './definition-store.js';
+export * from './definition-resolver.js';
+export * from './launcher.js';
+export * from './trace.js';
+export * from './run-context.js';
 export * from './published.js';