@purista/harness 1.0.0

package/dist/ports/model-provider.d.ts

@@ -0,0 +1,280 @@
+import type { JsonValue } from '../models/json.js';
+/**
+ * Model capabilities declared by aliases in `.models(...)`.
+ */
+export type ModelCapability = 
+/** Synchronous plain text generation. */
+'text'
+/** Streaming plain text generation. */
+ | 'text_stream'
+/** Synchronous structured object generation. */
+ | 'object'
+/** Streaming structured object generation. */
+ | 'object_stream'
+/** Function/tool calling support. */
+ | 'tool_use'
+/** Image input understanding. */
+ | 'vision_input'
+/** Audio input understanding. */
+ | 'audio_input'
+/** File input understanding. */
+ | 'file_input'
+/** Embedding vector generation. */
+ | 'embeddings'
+/** Document reranking. */
+ | 'rerank';
+/** Default generation parameters applied per alias. */
+export interface ModelDefaults {
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    stopSequences?: string[];
+    providerOptions?: Record<string, unknown>;
+}
+/** Per-call generation overrides. */
+export interface ModelCallOptions {
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    stopSequences?: string[];
+    providerOptions?: Record<string, unknown>;
+}
+/** Tool call envelope emitted by model adapters. */
+export interface ToolCallSpec {
+    id: string;
+    name: string;
+    arguments: JsonValue;
+}
+/** Multimodal message content part. */
+export type ContentPart = 
+/** Plain text input content. */
+{
+    kind: 'text';
+    text: string;
+}
+/** Inline image content encoded as base64 data. */
+ | {
+    kind: 'image';
+    mimeType: string;
+    dataBase64: string;
+}
+/** Remote image reference. */
+ | {
+    kind: 'image_url';
+    url: string;
+    mimeType?: string;
+}
+/** Inline audio content encoded as base64 data. */
+ | {
+    kind: 'audio';
+    mimeType: string;
+    dataBase64: string;
+}
+/** Inline file content encoded as base64 data. */
+ | {
+    kind: 'file';
+    mimeType: string;
+    dataBase64: string;
+    filename?: string;
+}
+/** Remote file reference. */
+ | {
+    kind: 'file_url';
+    url: string;
+    mimeType?: string;
+    filename?: string;
+};
+/** Optional data-only model feature descriptor exposed by provider packages. */
+export interface ModelProviderInfo {
+    providerId: string;
+    genAiSystem: string;
+    packageName?: string;
+    packageVersion?: string;
+    models?: Record<string, ModelFeatureSet>;
+}
+/** Static capabilities known for a provider model. */
+export interface ModelFeatureSet {
+    capabilities: readonly ModelCapability[];
+    contextWindow?: number;
+    maxOutputTokens?: number;
+    supportedInputParts?: readonly ContentPartKind[];
+    supportedOutputModes?: readonly OutputMode[];
+}
+/** Provider-neutral input content part kinds. */
+export type ContentPartKind = 'text' | 'image' | 'audio' | 'file';
+/** Provider-neutral output operation modes. */
+export type OutputMode = 'text' | 'object' | 'embedding' | 'rerank';
+/** Message schema shared across provider adapters. */
+export type ModelMessage = {
+    role: 'system';
+    content: string;
+} | {
+    role: 'user';
+    content: string | ContentPart[];
+} | {
+    role: 'assistant';
+    content: string | ContentPart[];
+    toolCalls?: ToolCallSpec[];
+} | {
+    role: 'tool';
+    toolCallId: string;
+    content: string;
+};
+/** Base request shape for all model-provider methods. */
+export interface BaseRequest {
+    model: string;
+    messages: ModelMessage[];
+    defaults?: ModelDefaults | undefined;
+    call?: ModelCallOptions | undefined;
+    signal: AbortSignal;
+    traceparent?: string | undefined;
+}
+/** Token usage accounting normalized across providers. */
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+}
+/** Normalized finish reasons from model providers. */
+export type FinishReason = 
+/** Natural model stop sequence. */
+'stop'
+/** Token budget reached. */
+ | 'length'
+/** Model requested tool calls. */
+ | 'tool_calls'
+/** Provider content filter interrupted generation. */
+ | 'content_filter'
+/** Provider or adapter error fallback. */
+ | 'error';
+/** Tool declaration exposed to model adapters. */
+export interface ModelToolSpec {
+    name: string;
+    description: string;
+    parameters: JsonValue;
+}
+/** Request for text/text-stream model methods. */
+export interface TextRequest extends BaseRequest {
+    tools?: ModelToolSpec[] | undefined;
+}
+/** Response from synchronous text generation. */
+export interface TextResponse {
+    content: string;
+    toolCalls?: ToolCallSpec[];
+    usage: TokenUsage;
+    finishReason: FinishReason;
+    raw?: unknown;
+}
+/** Stream chunk from text-stream generation. */
+export type TextStreamChunk = {
+    kind: 'delta';
+    text: string;
+} | {
+    kind: 'tool_call';
+    call: ToolCallSpec;
+} | {
+    kind: 'finish';
+    usage: TokenUsage;
+    finishReason: FinishReason;
+};
+/** Request for object/object-stream model methods. */
+export interface ObjectRequest<T extends JsonValue = JsonValue> extends BaseRequest {
+    schema: JsonValue;
+    schemaName?: string;
+    tools?: ModelToolSpec[] | undefined;
+}
+/** Response from synchronous structured object generation. */
+export interface ObjectResponse<T extends JsonValue = JsonValue> {
+    object: T;
+    toolCalls?: ToolCallSpec[];
+    usage: TokenUsage;
+    finishReason: FinishReason;
+    raw?: unknown;
+}
+/** Stream chunk from structured object streaming. */
+export type ObjectStreamChunk<T extends JsonValue = JsonValue> = {
+    kind: 'partial';
+    partial: JsonValue;
+} | {
+    kind: 'delta';
+    path: readonly (string | number)[];
+    value: JsonValue;
+} | {
+    kind: 'tool_call';
+    call: ToolCallSpec;
+} | {
+    kind: 'finish';
+    object: T;
+    usage: TokenUsage;
+    finishReason: FinishReason;
+};
+/** Request for embedding generation. */
+export interface EmbeddingRequest {
+    model: string;
+    input: string | readonly string[];
+    dimensions?: number;
+    call?: ModelCallOptions | undefined;
+    signal: AbortSignal;
+    traceparent?: string | undefined;
+}
+/** Response from embedding generation. */
+export interface EmbeddingResponse {
+    embeddings: readonly Embedding[];
+    usage: TokenUsage;
+    raw?: unknown;
+}
+/** Single embedding vector with input-order index. */
+export interface Embedding {
+    index: number;
+    vector: readonly number[];
+}
+/** Request for document reranking. */
+export interface RerankRequest {
+    model: string;
+    query: string;
+    documents: readonly RerankDocument[];
+    topN?: number;
+    call?: ModelCallOptions | undefined;
+    signal: AbortSignal;
+    traceparent?: string | undefined;
+}
+/** Rerankable document. */
+export interface RerankDocument {
+    id: string;
+    text: string;
+    metadata?: Record<string, JsonValue>;
+}
+/** Response from document reranking. */
+export interface RerankResponse {
+    results: readonly RerankResult[];
+    usage?: TokenUsage;
+    raw?: unknown;
+}
+/** Single rerank result referencing one submitted document. */
+export interface RerankResult {
+    id: string;
+    index: number;
+    score: number;
+    metadata?: Record<string, JsonValue>;
+}
+/** Provider adapter interface implemented by packages such as `@purista/harness-openai`. */
+export interface ModelProvider {
+    readonly id: string;
+    readonly genAiSystem: string;
+    readonly info?: ModelProviderInfo;
+    text?(req: TextRequest): Promise<TextResponse>;
+    textStream?(req: TextRequest): AsyncIterable<TextStreamChunk>;
+    object?<T extends JsonValue = JsonValue>(req: ObjectRequest<T>): Promise<ObjectResponse<T>>;
+    objectStream?<T extends JsonValue = JsonValue>(req: ObjectRequest<T>): AsyncIterable<ObjectStreamChunk<T>>;
+    embed?(req: EmbeddingRequest): Promise<EmbeddingResponse>;
+    rerank?(req: RerankRequest): Promise<RerankResponse>;
+    close?(): Promise<void>;
+}
+/** Alias entry used in harness model configuration. */
+export interface ModelAlias {
+    provider: ModelProvider;
+    model: string;
+    capabilities: readonly ModelCapability[];
+    defaults?: ModelDefaults;
+    providerOptions?: Record<string, unknown>;
+}

package/dist/ports/model-provider.js

@@ -0,0 +1 @@
+export {};

package/dist/ports/state.d.ts

@@ -0,0 +1,72 @@
+import { StateError } from '../errors/index.js';
+import type { Message, PersistedRunEvent, RunRecord, SessionRecord } from '../models/state.js';
+import type { Logger } from '../logger/index.js';
+import type { TelemetryShim } from '../telemetry/index.js';
+import type { HarnessAdapterContext } from './harness-context.js';
+/** Fields allowed when marking a run as finished. */
+export type FinishRunPatch = Pick<RunRecord, 'status' | 'finishedAt' | 'output' | 'error'>;
+/**
+ * Persistence port for session state, history, run metadata, and streamed events.
+ *
+ * Implement this interface to provide durable backends (Postgres, Redis, etc.).
+ */
+export interface StateStore {
+    getSession(id: string): Promise<SessionRecord | undefined>;
+    upsertSession(record: SessionRecord): Promise<void>;
+    closeSession(id: string): Promise<void>;
+    appendMessages(sessionId: string, messages: Message[]): Promise<void>;
+    listMessages(sessionId: string, opts?: {
+        limit?: number;
+        before?: string;
+    }): Promise<Message[]>;
+    clearMessages(sessionId: string): Promise<void>;
+    createRun(record: RunRecord): Promise<void>;
+    finishRun(runId: string, patch: FinishRunPatch): Promise<void>;
+    getRun(runId: string): Promise<RunRecord | undefined>;
+    listRuns(sessionId: string, opts?: {
+        limit?: number;
+        before?: string;
+    }): Promise<RunRecord[]>;
+    appendEvents(runId: string, events: PersistedRunEvent[]): Promise<void>;
+    listEvents(runId: string, opts?: {
+        limit?: number;
+        after?: string;
+    }): Promise<PersistedRunEvent[]>;
+    close?(): Promise<void>;
+}
+/**
+ * Optional base for durable state adapters.
+ *
+ * Concrete adapters still implement the `StateStore` port directly, while this
+ * base provides shared error normalization so provider-specific code can stay
+ * focused on mapping records to the backing store.
+ */
+export declare abstract class StateStoreAdapterBase implements StateStore {
+    protected logger: Logger | undefined;
+    protected telemetry: TelemetryShim | undefined;
+    protected harnessName: string | undefined;
+    abstract getSession(id: string): Promise<SessionRecord | undefined>;
+    abstract upsertSession(record: SessionRecord): Promise<void>;
+    abstract closeSession(id: string): Promise<void>;
+    abstract appendMessages(sessionId: string, messages: Message[]): Promise<void>;
+    abstract listMessages(sessionId: string, opts?: {
+        limit?: number;
+        before?: string;
+    }): Promise<Message[]>;
+    abstract clearMessages(sessionId: string): Promise<void>;
+    abstract createRun(record: RunRecord): Promise<void>;
+    abstract finishRun(runId: string, patch: FinishRunPatch): Promise<void>;
+    abstract getRun(runId: string): Promise<RunRecord | undefined>;
+    abstract listRuns(sessionId: string, opts?: {
+        limit?: number;
+        before?: string;
+    }): Promise<RunRecord[]>;
+    abstract appendEvents(runId: string, events: PersistedRunEvent[]): Promise<void>;
+    abstract listEvents(runId: string, opts?: {
+        limit?: number;
+        after?: string;
+    }): Promise<PersistedRunEvent[]>;
+    close(): Promise<void>;
+    configureHarnessContext(context: HarnessAdapterContext): void;
+    protected stateError(op: Parameters<StateStore['appendEvents']>[0] extends never ? never : ConstructorParameters<typeof StateError>[1]['op'], message: string, error: unknown, reason?: string): StateError;
+}

package/dist/ports/state.js

@@ -0,0 +1,24 @@
+import { StateError } from '../errors/index.js';
+/**
+ * Optional base for durable state adapters.
+ *
+ * Concrete adapters still implement the `StateStore` port directly, while this
+ * base provides shared error normalization so provider-specific code can stay
+ * focused on mapping records to the backing store.
+ */
+export class StateStoreAdapterBase {
+    logger;
+    telemetry;
+    harnessName;
+    async close() { }
+    configureHarnessContext(context) {
+        this.logger ??= context.logger;
+        this.telemetry ??= context.telemetry;
+        this.harnessName ??= context.harnessName;
+    }
+    stateError(op, message, error, reason) {
+        if (error instanceof StateError)
+            return error;
+        return new StateError(message, { op, ...(reason ? { reason } : {}) }, error);
+    }
+}

package/dist/runtime/durable.d.ts

@@ -0,0 +1,134 @@
+import type { AdapterCapability } from '../ports/capabilities.js';
+import type { JsonValue } from '../models/json.js';
+import type { RunStatus, SerializedError } from '../models/state.js';
+/** Non-terminal run status used while durable work can still be resumed. */
+export type DurableActiveRunStatus = 'running';
+/** Terminal run statuses that must never be resumed by a durable runtime. */
+export type DurableTerminalRunStatus = Exclude<RunStatus, DurableActiveRunStatus>;
+/** Durable run lifecycle status. */
+export type DurableRunStatus = DurableActiveRunStatus | DurableTerminalRunStatus;
+/** Input metadata required to create or retry a durable run. */
+export interface DurableRunStart {
+    /** Stable run id. Retries of the same logical run must reuse this value. */
+    readonly runId: string;
+    /** Stable session id owned by the run while it mutates session state. */
+    readonly sessionId: string;
+    /** Worker/process id requesting ownership of the run. */
+    readonly workerId: string;
+    /** Initial durable step id. Retried metadata preserves this value. */
+    readonly stepId: string;
+    /** Original run input. Retried metadata preserves this value. */
+    readonly input: JsonValue;
+    /** Optional caller-supplied attempt. The runtime may increase it on retry. */
+    readonly attempt?: number;
+    /** Adapter-neutral metadata persisted with the durable run. */
+    readonly metadata?: Record<string, JsonValue>;
+}
+/** Exclusive ownership token returned by a durable runtime. */
+export interface DurableRunLease {
+    /** Stable run id owned by this lease. */
+    readonly runId: string;
+    /** Stable session id owned by this lease. */
+    readonly sessionId: string;
+    /** Worker/process id that owns this lease. */
+    readonly workerId: string;
+    /** Runtime-issued lease id. */
+    readonly leaseId: string;
+    /** Current attempt number for this run. */
+    readonly attempt: number;
+    /** True when the run has a committed checkpoint to resume from. */
+    readonly resumed: boolean;
+    /** Metadata from the original run start record with runtime attempt applied. */
+    readonly start: DurableRunStart & {
+        readonly attempt: number;
+    };
+    /** Last committed checkpoint, if any. */
+    readonly checkpoint?: RunCheckpoint;
+    /** Releases this in-memory lease without making the run terminal. */
+    release(): Promise<void>;
+}
+/** Stable checkpoint boundary committed by a durable runtime. */
+export interface RunCheckpoint {
+    /** Stable run id. */
+    readonly runId: string;
+    /** Stable session id. */
+    readonly sessionId: string;
+    /** Runtime-issued lease id that owns this checkpoint write. */
+    readonly leaseId: string;
+    /** Worker/process id that owns this checkpoint write. */
+    readonly workerId: string;
+    /** Stable step id for the committed boundary. */
+    readonly stepId: string;
+    /** Original run input associated with this retry chain. */
+    readonly input: JsonValue;
+    /** Attempt that produced this checkpoint. */
+    readonly attempt: number;
+    /** Monotonic checkpoint sequence for the run. */
+    readonly sequence: number;
+    /** JSON-serializable checkpoint payload. */
+    readonly output?: JsonValue;
+    /** Adapter-neutral checkpoint metadata. */
+    readonly metadata?: Record<string, JsonValue>;
+    /** ISO timestamp for the commit. */
+    readonly committedAt?: string;
+}
+/** Patch used to make a durable run terminal. */
+export interface FinishRunPatch {
+    /** Terminal run status. */
+    readonly status: DurableTerminalRunStatus;
+    /** Optional terminal output. */
+    readonly output?: JsonValue;
+    /** Optional terminal error. */
+    readonly error?: SerializedError;
+    /** ISO timestamp for terminal completion. */
+    readonly finishedAt?: string;
+}
+/** Optional failure injection settings for the in-memory durable runtime. */
+export interface InMemoryDurableRuntimeOptions {
+    /**
+     * Throws after committing the Nth checkpoint. The checkpoint remains stored,
+     * which lets tests prove resume starts from the last consistent boundary.
+     */
+    readonly failAfterCheckpoint?: number;
+}
+/** Durable runtime adapter contract for checkpointed execution. */
+export interface DurableRuntime {
+    /** Adapter capabilities supported by this runtime. */
+    readonly capabilities: readonly AdapterCapability[];
+    /** Starts or retries a run and returns an exclusive lease. */
+    startRun(record: DurableRunStart): Promise<DurableRunLease>;
+    /** Loads the last committed checkpoint for a run. */
+    loadCheckpoint(runId: string): Promise<RunCheckpoint | undefined>;
+    /** Commits a stable checkpoint boundary. */
+    commitCheckpoint(checkpoint: RunCheckpoint): Promise<void>;
+    /** Marks a run terminal and releases any owned lease. */
+    finishRun(runId: string, patch: FinishRunPatch): Promise<void>;
+    /** Executes a callback while holding an exclusive session lock. */
+    withSessionLock<T>(sessionId: string, fn: () => Promise<T>): Promise<T>;
+}
+/** Error thrown when a terminal durable run is started again. */
+export declare class DurableTerminalRunError extends Error {
+    constructor(runId: string, status: DurableTerminalRunStatus);
+}
+/** Error thrown when a durable run/session is already owned by another worker. */
+export declare class DurableRunLeaseError extends Error {
+    constructor(message: string);
+}
+/** Returns true when a durable run status is terminal. */
+export declare function isTerminalRunStatus(status: DurableRunStatus): status is DurableTerminalRunStatus;
+/**
+ * Creates a self-contained in-memory durable runtime for tests and prototypes.
+ *
+ * @example
+ * ```ts
+ * const runtime = inMemoryDurableRuntime({ failAfterCheckpoint: 1 })
+ * const lease = await runtime.startRun({
+ *   runId: 'run-1',
+ *   sessionId: 'session-1',
+ *   workerId: 'worker-1',
+ *   stepId: 'draft',
+ *   input: { topic: 'durability' }
+ * })
+ * ```
+ */
+export declare function inMemoryDurableRuntime(options?: InMemoryDurableRuntimeOptions): DurableRuntime;

package/dist/runtime/durable.js

@@ -0,0 +1,185 @@
+/** Error thrown when a terminal durable run is started again. */
+export class DurableTerminalRunError extends Error {
+    constructor(runId, status) {
+        super(`Durable run "${runId}" is terminal (${status}) and cannot be resumed.`);
+        this.name = 'DurableTerminalRunError';
+    }
+}
+/** Error thrown when a durable run/session is already owned by another worker. */
+export class DurableRunLeaseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DurableRunLeaseError';
+    }
+}
+/** Returns true when a durable run status is terminal. */
+export function isTerminalRunStatus(status) {
+    return status === 'succeeded' || status === 'failed' || status === 'cancelled';
+}
+class AsyncMutex {
+    current = Promise.resolve();
+    async lock(fn) {
+        const prev = this.current;
+        let release;
+        this.current = new Promise((resolve) => {
+            release = resolve;
+        });
+        await prev;
+        try {
+            return await fn();
+        }
+        finally {
+            release?.();
+        }
+    }
+}
+class InMemoryDurableRuntime {
+    options;
+    capabilities = [
+        'runtime.checkpoint',
+        'runtime.retry',
+        'runtime.distributed_lock',
+        'runtime.resume_from_checkpoint'
+    ];
+    runs = new Map();
+    runLeases = new Map();
+    sessionLeases = new Map();
+    sessionLocks = new Map();
+    leaseCounter = 0;
+    checkpointCommitCount = 0;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async startRun(record) {
+        return this.withSessionLock(record.sessionId, async () => {
+            const current = this.runs.get(record.runId);
+            if (current && isTerminalRunStatus(current.status)) {
+                throw new DurableTerminalRunError(record.runId, current.status);
+            }
+            this.assertNoConflictingLease(record);
+            const state = current ?? {
+                start: record,
+                status: 'running',
+                attempt: Math.max(1, record.attempt ?? 1)
+            };
+            if (current) {
+                state.attempt += 1;
+            }
+            this.runs.set(record.runId, state);
+            const lease = {
+                leaseId: `lease-${++this.leaseCounter}`,
+                runId: record.runId,
+                sessionId: record.sessionId,
+                workerId: record.workerId
+            };
+            this.runLeases.set(record.runId, lease);
+            this.sessionLeases.set(record.sessionId, lease);
+            return this.toLease(state, lease);
+        });
+    }
+    async loadCheckpoint(runId) {
+        return this.runs.get(runId)?.checkpoint;
+    }
+    async commitCheckpoint(checkpoint) {
+        await this.withSessionLock(checkpoint.sessionId, async () => {
+            const lease = this.runLeases.get(checkpoint.runId);
+            if (!lease || lease.leaseId !== checkpoint.leaseId || lease.workerId !== checkpoint.workerId) {
+                throw new DurableRunLeaseError(`Durable run "${checkpoint.runId}" is not owned by this lease.`);
+            }
+            const state = this.runs.get(checkpoint.runId);
+            if (!state) {
+                throw new DurableRunLeaseError(`Durable run "${checkpoint.runId}" has not been started.`);
+            }
+            if (isTerminalRunStatus(state.status)) {
+                throw new DurableTerminalRunError(checkpoint.runId, state.status);
+            }
+            const committedAt = checkpoint.committedAt ?? new Date().toISOString();
+            state.checkpoint = { ...checkpoint, committedAt };
+            this.checkpointCommitCount += 1;
+            if (this.options.failAfterCheckpoint === this.checkpointCommitCount) {
+                this.releaseLease(lease);
+                throw new Error(`Injected durable runtime failure after checkpoint ${this.checkpointCommitCount}.`);
+            }
+        });
+    }
+    async finishRun(runId, patch) {
+        const state = this.runs.get(runId);
+        if (!state)
+            return;
+        state.status = patch.status;
+        state.finished = {
+            ...patch,
+            finishedAt: patch.finishedAt ?? new Date().toISOString()
+        };
+        const lease = this.runLeases.get(runId);
+        if (lease) {
+            this.releaseLease(lease);
+        }
+    }
+    async withSessionLock(sessionId, fn) {
+        let lock = this.sessionLocks.get(sessionId);
+        if (!lock) {
+            lock = new AsyncMutex();
+            this.sessionLocks.set(sessionId, lock);
+        }
+        return lock.lock(fn);
+    }
+    assertNoConflictingLease(record) {
+        const runLease = this.runLeases.get(record.runId);
+        if (runLease && runLease.workerId !== record.workerId) {
+            throw new DurableRunLeaseError(`Durable run "${record.runId}" is already owned by worker "${runLease.workerId}".`);
+        }
+        const sessionLease = this.sessionLeases.get(record.sessionId);
+        if (sessionLease && (sessionLease.runId !== record.runId || sessionLease.workerId !== record.workerId)) {
+            throw new DurableRunLeaseError(`Durable session "${record.sessionId}" is already owned by run "${sessionLease.runId}".`);
+        }
+    }
+    toLease(state, lease) {
+        return {
+            runId: lease.runId,
+            sessionId: lease.sessionId,
+            workerId: lease.workerId,
+            leaseId: lease.leaseId,
+            attempt: state.attempt,
+            resumed: Boolean(state.checkpoint),
+            start: {
+                ...state.start,
+                attempt: state.attempt
+            },
+            ...(state.checkpoint ? { checkpoint: state.checkpoint } : {}),
+            release: async () => {
+                await this.withSessionLock(lease.sessionId, async () => {
+                    this.releaseLease(lease);
+                });
+            }
+        };
+    }
+    releaseLease(lease) {
+        const activeRunLease = this.runLeases.get(lease.runId);
+        if (activeRunLease?.leaseId === lease.leaseId) {
+            this.runLeases.delete(lease.runId);
+        }
+        const activeSessionLease = this.sessionLeases.get(lease.sessionId);
+        if (activeSessionLease?.leaseId === lease.leaseId) {
+            this.sessionLeases.delete(lease.sessionId);
+        }
+    }
+}
+/**
+ * Creates a self-contained in-memory durable runtime for tests and prototypes.
+ *
+ * @example
+ * ```ts
+ * const runtime = inMemoryDurableRuntime({ failAfterCheckpoint: 1 })
+ * const lease = await runtime.startRun({
+ *   runId: 'run-1',
+ *   sessionId: 'session-1',
+ *   workerId: 'worker-1',
+ *   stepId: 'draft',
+ *   input: { topic: 'durability' }
+ * })
+ * ```
+ */
+export function inMemoryDurableRuntime(options) {
+    return new InMemoryDurableRuntime(options);
+}