@hunterzhu/pulse-runtime 0.1.0

package/dist/dsl/program.js

@@ -0,0 +1,756 @@
+import { z } from 'zod';
+import { globalContextRef, laneContextRef } from '../core/types.js';
+import { createDraftProxy } from './context-proxy.js';
+import { contentHash, stableSerialize } from '../context/builder.js';
+function target(step, fallback) {
+    if (typeof step === 'string')
+        return { step };
+    if ('step' in step)
+        return { step: step.step };
+    if ('complete' in step)
+        return { step: fallback, action: { type: 'complete', result: step.complete.value ?? null, ...(step.complete.privacy === undefined ? {} : { privacy: step.complete.privacy }), ...(step.complete.children === undefined ? {} : { children: step.complete.children }) } };
+    return { step: fallback, action: { type: 'fail', error: { code: step.fail.code, message: step.fail.message, ...(step.fail.retryable === undefined ? {} : { retryable: step.fail.retryable }), ...(step.fail.details === undefined ? {} : { details: step.fail.details }) }, ...(step.fail.privacy === undefined ? {} : { privacy: step.fail.privacy }), ...(step.fail.derivedFrom === undefined ? {} : { derivedFrom: step.fail.derivedFrom }) } };
+}
+function clone(value) { return structuredClone(value); }
+function deepFreeze(value, seen = new Set()) {
+    if (!value || typeof value !== 'object' || seen.has(value))
+        return value;
+    seen.add(value);
+    for (const child of Object.values(value))
+        deepFreeze(child, seen);
+    return Object.freeze(value);
+}
+function asJson(value) { return value; }
+function scalarProjection(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')
+        return value;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).filter(([, child]) => child === null || typeof child === 'string' || typeof child === 'number' || typeof child === 'boolean').map(([key, child]) => [key, child]));
+}
+function boundedInstruction(value) {
+    if (Buffer.byteLength(value, 'utf8') > 2048)
+        throw Object.assign(new Error('Instruction exceeds the 2 KB DSL limit.'), { code: 'INSTRUCTION_TOO_LARGE', retryable: false });
+    return value;
+}
+function programLLMInput(config, input) {
+    return { ...input, ...(config.system === undefined ? {} : { system: config.system }), ...(config.toolSet === undefined ? {} : { toolSetId: config.toolSet }) };
+}
+function affinityAdvice(ctx) {
+    const input = ctx.resumeInput;
+    if (!input || input.type !== 'control_error' || input.error.code !== 'FORK_AFFINITY_COLLAPSIBLE')
+        return undefined;
+    const details = input.error.details;
+    if (!details || typeof details !== 'object' || Array.isArray(details))
+        return undefined;
+    const groups = details.groups;
+    if (!Array.isArray(groups))
+        return undefined;
+    return groups.flatMap((group) => {
+        if (!group || typeof group !== 'object' || Array.isArray(group))
+            return [];
+        const value = group;
+        const keys = Array.isArray(value.keys) ? value.keys.filter((key) => typeof key === 'string') : [];
+        const signals = Array.isArray(value.signals) ? value.signals.filter((signal) => typeof signal === 'string') : [];
+        return keys.length > 1 ? [{ keys, signals }] : [];
+    });
+}
+function sameProgram(left, right) {
+    return left.program.programId === right.program.programId && left.program.programVersion === right.program.programVersion && left.program.step === right.program.step && JSON.stringify(left.program.locals ?? {}) === JSON.stringify(right.program.locals ?? {});
+}
+function normalizeDependsOn(dependencies) {
+    return dependencies?.map((dependency) => 'sibling' in dependency ? { key: dependency.sibling, target: { local: dependency.sibling }, condition: dependency.condition } : dependency);
+}
+function joinOptions(value, legacy) {
+    return { condition: value?.condition ?? legacy.condition ?? 'settled', mode: legacy.mode ?? 'all', ...(legacy.quorum === undefined ? {} : { quorum: legacy.quorum }), ...(legacy.deadlineAt === undefined ? {} : { deadlineAt: legacy.deadlineAt }), onUnsatisfied: value?.onUnsatisfied ?? 'resume_with_error', ...(value?.onCancelled === undefined ? {} : { onCancelled: value.onCancelled }) };
+}
+function seriesOrder(members) {
+    const byKey = new Map(members.map((lane) => [lane.key, lane]));
+    const visiting = new Set();
+    const visited = new Set();
+    const ordered = [];
+    const visit = (key) => {
+        if (visited.has(key))
+            return true;
+        if (visiting.has(key))
+            return false;
+        visiting.add(key);
+        const lane = byKey.get(key);
+        if (!lane)
+            return false;
+        for (const dependency of lane.dependsOn ?? [])
+            if ('local' in dependency.target && byKey.has(dependency.target.local) && !visit(dependency.target.local))
+                return false;
+        visiting.delete(key);
+        visited.add(key);
+        ordered.push(lane);
+        return true;
+    };
+    return members.every((lane) => visit(lane.key)) ? ordered : undefined;
+}
+function collapseAffinityLanes(name, lanes, groups, enabled, joinMode, condition) {
+    if (!enabled || joinMode !== 'all' || condition !== 'settled')
+        return { lanes };
+    const byKey = new Map(lanes.map((lane) => [lane.key, lane]));
+    const collapsed = new Set();
+    const aliases = {};
+    const output = [];
+    let groupIndex = 0;
+    for (const group of groups) {
+        const members = group.keys.map((key) => byKey.get(key)).filter((lane) => lane !== undefined);
+        if (members.length !== group.keys.length || members.some((lane) => (lane.dependsOn ?? []).some((dependency) => !('local' in dependency.target) || !group.keys.includes(dependency.target.local))) || members.some((lane) => !sameProgram(lane, members[0])))
+            continue;
+        const ordered = seriesOrder(members);
+        if (!ordered)
+            continue;
+        const key = `__series_${name}_${groupIndex++}`;
+        const member = ordered[0];
+        const internalDependencies = Object.fromEntries(ordered.flatMap((lane) => {
+            const dependsOn = (lane.dependsOn ?? []).filter((dependency) => 'local' in dependency.target).map((dependency) => ({ key: dependency.target.local, condition: dependency.condition }));
+            return dependsOn.length ? [[lane.key, { dependsOn }]] : [];
+        }));
+        output.push({ key, goal: ordered.map((lane) => `${lane.key}: ${lane.goal}`).join('\n'), program: member.program, ...(member.priority === undefined ? {} : { priority: member.priority }), ...(member.contextVersion === undefined ? {} : { contextVersion: member.contextVersion }), ...(member.resources === undefined ? {} : { resources: member.resources }), series: { member: member.program, keys: ordered.map((lane) => lane.key), goals: Object.fromEntries(ordered.map((lane) => [lane.key, lane.goal])), ...(Object.keys(internalDependencies).length ? { members: internalDependencies } : {}), onMemberFailure: 'continue' } });
+        for (const lane of ordered) {
+            collapsed.add(lane.key);
+            aliases[lane.key] = key;
+        }
+    }
+    output.push(...lanes.filter((lane) => !collapsed.has(lane.key)));
+    return Object.keys(aliases).length ? { lanes: output, aliases } : { lanes };
+}
+function joinedOutcome(ctx, dependency, key) {
+    if (dependency.outcome.resultRef === undefined)
+        return dependency.outcome;
+    const value = readResult(ctx, dependency.outcome.resultRef);
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return dependency.outcome;
+    const member = value.results;
+    if (!member || typeof member !== 'object' || Array.isArray(member))
+        return dependency.outcome;
+    const result = member[key];
+    if (!result || typeof result !== 'object' || Array.isArray(result))
+        return dependency.outcome;
+    const record = result;
+    const status = record.status;
+    if (status !== 'succeeded' && status !== 'failed' && status !== 'cancelled')
+        return dependency.outcome;
+    return { status, resultRef: dependency.outcome.resultRef, ...(record.result === undefined ? {} : { result: record.result }), ...(record.error && typeof record.error === 'object' && !Array.isArray(record.error) ? { error: record.error } : {}), ...(typeof record.reason === 'string' ? { reason: record.reason } : {}), ...(Array.isArray(record.unresolvedEffectIds) ? { unresolvedEffectIds: record.unresolvedEffectIds.filter((value) => typeof value === 'string') } : {}) };
+}
+function zodJsonSchema(schema) {
+    const definition = schema?._def;
+    if (!definition)
+        return {};
+    const typeName = definition.typeName;
+    let result;
+    if (typeName === 'ZodObject') {
+        const shape = typeof definition.shape === 'function' ? definition.shape() : definition.shape ?? {};
+        const properties = {};
+        const required = [];
+        for (const [key, child] of Object.entries(shape)) {
+            properties[key] = zodJsonSchema(child);
+            if (!child.isOptional())
+                required.push(key);
+        }
+        result = { type: 'object', properties, ...(required.length ? { required } : {}) };
+    }
+    else if (typeName === 'ZodString')
+        result = { type: 'string' };
+    else if (typeName === 'ZodNumber')
+        result = { type: 'number' };
+    else if (typeName === 'ZodBoolean')
+        result = { type: 'boolean' };
+    else if (typeName === 'ZodNull')
+        result = { type: 'null' };
+    else if (typeName === 'ZodArray')
+        result = { type: 'array', items: zodJsonSchema(definition.type) };
+    else if (typeName === 'ZodOptional' || typeName === 'ZodDefault')
+        return zodJsonSchema(definition.innerType ?? definition.type);
+    else if (typeName === 'ZodNullable')
+        result = { anyOf: [zodJsonSchema(definition.innerType), { type: 'null' }] };
+    else if (typeName === 'ZodEnum')
+        result = { enum: [...(definition.values ?? [])] };
+    else if (typeName === 'ZodLiteral')
+        result = { const: definition.value ?? null };
+    else if (typeName === 'ZodUnion')
+        result = { anyOf: (definition.options ?? []).map(zodJsonSchema) };
+    else if (typeName === 'ZodEffects')
+        return zodJsonSchema(definition.schema);
+    else if (typeName === undefined)
+        result = {};
+    else
+        throw new Error(`UNSUPPORTED_OUTPUT_SCHEMA:${typeName}`);
+    return definition.description === undefined ? result : { ...result, description: definition.description };
+}
+function resultVisible(context, ref) { return context.lane.visibleResultRefs === undefined || context.lane.visibleResultRefs.has(ref); }
+function findResult(context, ref) { return resultVisible(context, ref) ? context.state.results.get(ref)?.value : undefined; }
+function collectResumeResultRefs(input, refs) {
+    if (!input)
+        return;
+    if (input.type === 'control_error') {
+        collectResumeResultRefs(input.original, refs);
+        return;
+    }
+    if (input.type !== 'wait')
+        return;
+    for (const dependency of Object.values(input.resolution.dependencies)) {
+        if (dependency.state !== 'settled' && dependency.state !== 'ignored')
+            continue;
+        if (dependency.outcome.resultRef)
+            refs.add(dependency.outcome.resultRef);
+        for (const ref of dependency.outcome.rejectedOutputRefs ?? [])
+            refs.add(ref);
+    }
+}
+function annotateAction(action, derivedFrom) {
+    if (!derivedFrom.length)
+        return action;
+    if (action.type === 'complete' || action.type === 'fail')
+        return { ...action, derivedFrom: [...new Set([...derivedFrom, ...(action.derivedFrom ?? [])])] };
+    if (action.type === 'submit_effects')
+        return { ...action, effects: action.effects.map((effect) => ({ ...effect, derivedFrom: [...new Set([...derivedFrom, ...(effect.derivedFrom ?? [])])] })) };
+    return action;
+}
+const resultReaders = new WeakMap();
+function readResult(ctx, ref) { return resultReaders.get(ctx)?.(ref); }
+function waitFailure(ctx) {
+    const resolution = ctx.resumeInput?.type === 'wait' ? ctx.resumeInput.resolution : undefined;
+    if (!resolution)
+        return undefined;
+    let dependencyError;
+    for (const dependency of Object.values(resolution.dependencies)) {
+        if (dependency.state !== 'pending' && dependency.outcome.status === 'failed' && dependency.outcome.error && !(dependency.outcome.rejectedOutputRefs?.length)) {
+            dependencyError = dependency.outcome.error;
+            break;
+        }
+    }
+    if (dependencyError)
+        return dependencyError;
+    return resolution.status === 'unsatisfied' ? resolution.error ?? { code: 'WAIT_UNSATISFIED', message: 'Wait did not reach its required outcome.' } : undefined;
+}
+function sdkLocals(locals) {
+    if (!locals || typeof locals !== 'object' || Array.isArray(locals))
+        return {};
+    const value = locals.$sdk;
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function ordinaryLocals(locals) {
+    return locals && typeof locals === 'object' && !Array.isArray(locals) ? locals : {};
+}
+function makeContext(context, initialState) {
+    const draft = clone(initialState);
+    const readonlyState = deepFreeze(clone(initialState));
+    const draftProxy = draft && typeof draft === 'object' ? createDraftProxy(draft) : undefined;
+    let delta;
+    const actions = [];
+    const derivedRefs = new Set();
+    let adoptImmediately = false;
+    const agent = context.state.agents.get(context.lane.agentId);
+    const globalVersion = context.lane.contextSnapshotVersion;
+    const globalDraft = clone(agent?.globalVersions.get(globalVersion) ?? {});
+    const global = deepFreeze(clone(globalDraft));
+    const globalDraftProxy = globalDraft && typeof globalDraft === 'object' && !Array.isArray(globalDraft) ? createDraftProxy(globalDraft) : undefined;
+    if (agent)
+        derivedRefs.add(globalContextRef(agent.id, globalVersion));
+    derivedRefs.add(laneContextRef(context.lane.id, context.lane.context.version));
+    collectResumeResultRefs(context.resumeInput, derivedRefs);
+    for (const record of context.lane.context.history)
+        for (const ref of record.resultRefs)
+            derivedRefs.add(ref);
+    const history = context.lane.context.history.map((record) => ({
+        seq: record.seq,
+        hash: contentHash({ seq: record.seq, ...(record.effectId === undefined ? {} : { effectId: record.effectId }), instruction: record.instruction, resultRefs: record.resultRefs, ...(record.resultSelection === undefined ? {} : { resultSelection: record.resultSelection }), ...(record.result === undefined ? {} : { result: record.result }), ...(record.findings === undefined ? {} : { findings: record.findings }), output: record.output, privacy: record.privacy, ...(record.privacyTaints === undefined ? {} : { privacyTaints: record.privacyTaints }) }),
+        ...(record.effectId === undefined ? {} : { effectId: record.effectId }),
+        resultRefs: [...record.resultRefs],
+        ...(record.resultSelection === undefined ? {} : { resultSelection: clone(record.resultSelection) }),
+        ...(record.result === undefined ? {} : { result: record.result }),
+        ...(record.findings === undefined ? {} : { findings: [...record.findings] }),
+        privacy: record.privacy,
+        ...(record.privacyTaints === undefined ? {} : { privacyTaints: clone(record.privacyTaints) }),
+    }));
+    const resultMeta = (ref) => {
+        const result = resultVisible(context, ref) ? context.state.results.get(ref) : undefined;
+        if (!result)
+            return undefined;
+        const value = result.value ?? null;
+        return {
+            ref,
+            privacy: result.privacy,
+            derivedFrom: [...result.derivedFrom],
+            sizeBytes: result.sizeBytes ?? Buffer.byteLength(stableSerialize(value), 'utf8'),
+            hash: result.contentHash ?? contentHash(value),
+            producer: result.producer ?? (result.effectId === undefined ? { kind: 'lane', id: context.lane.id } : { kind: 'effect', id: result.effectId }),
+            ...(result.summary === undefined ? {} : { summary: clone(result.summary) }),
+        };
+    };
+    const globalDelta = (value) => {
+        const ops = typeof value.ops === 'function' ? (() => { if (!globalDraftProxy)
+            throw Object.assign(new Error('GLOBAL_DRAFT_REQUIRES_OBJECT'), { code: 'GLOBAL_DRAFT_REQUIRES_OBJECT', retryable: false }); value.ops(globalDraftProxy.draft); return globalDraftProxy.changes().ops; })() : value.ops;
+        delta = { target: 'global', baseVersion: agent?.latestGlobalVersion ?? 0, sourceLaneId: context.lane.id, ops: clone(ops), ...(value.privacy === undefined ? {} : { privacy: value.privacy }), proposal: value.proposal };
+    };
+    const ctx = {
+        lane: context.lane, goal: context.lane.goal, global, globalVersion, laneState: readonlyState, history, now: context.now, ...(context.lane.progressWatchdog === undefined ? {} : { watchdog: context.lane.progressWatchdog }), ...(context.resumeInput ? { resumeInput: context.resumeInput } : {}),
+        results: { meta: resultMeta, summary: (ref) => { if (context.state.results.has(ref) && resultVisible(context, ref))
+                derivedRefs.add(ref); return resultMeta(ref)?.summary; } },
+        mergeProposals: [...context.state.mergeProposals.values()].filter((proposal) => proposal.agentId === context.lane.agentId).map((proposal) => { for (const ref of proposal.delta.derivedFrom ?? [])
+            derivedRefs.add(ref); return clone(proposal); }),
+        mutateLane: (mutator) => { mutator((draftProxy?.draft ?? draft)); const changes = draftProxy?.changes(); delta = { target: 'lane', baseVersion: context.lane.context.version, ops: changes?.ops.map((op) => op.op === 'set' ? { op: 'set', path: op.path, value: asJson(op.value) } : op.op === 'append' ? { op: 'append', path: op.path, value: asJson(op.value) } : { op: 'remove', path: op.path }) ?? [] }; },
+        proposeGlobal: (value) => globalDelta({ ...value, proposal: true }),
+        commitGlobal: (value) => { globalDelta({ ...value, proposal: false }); adoptImmediately = value.adoptImmediately ?? false; },
+        adoptContext: (version) => actions.push({ type: 'adopt_context', version }),
+        cancelLane: (laneId, reason) => actions.push({ type: 'cancel_lane', laneId, reason }),
+        proposeCancel: (laneId, reason) => actions.push({ type: 'propose_cancel', laneId, reason }),
+        trace: (message) => { context.observe?.({ type: 'trace', data: typeof message === 'string' ? message : asJson(message) }); },
+    };
+    resultReaders.set(ctx, (ref) => { if (context.state.results.has(ref) && resultVisible(context, ref))
+        derivedRefs.add(ref); return findResult(context, ref); });
+    return { ctx, getDelta: () => delta, getActions: () => actions, getDerivedRefs: () => [...derivedRefs], getAdoptImmediately: () => adoptImmediately };
+}
+export class StepBuilder {
+    config;
+    handlers = new Map();
+    /**
+     * History compaction is a macro boundary concern. Internal handlers such as
+     * `:submit`, `:decode`, `:join`, and `:resume` must consume the pending
+     * Wait input before the next compaction check can run.
+     */
+    compactionBoundaries = new Set();
+    boundaryHandler;
+    constructor(config) {
+        this.config = config;
+    }
+    addStep(name, handler) { this.handlers.set(name, handler); this.compactionBoundaries.add(name); return this; }
+    onErrorBoundary(handler) { this.boundaryHandler = handler; return this; }
+    addStructuredLLMStep(name, options) {
+        this.compactionBoundaries.add(name);
+        const submit = `${name}:submit`;
+        const decode = `${name}:decode`;
+        const maxCorrectionRounds = options.selfCorrect?.maxRounds ?? 1;
+        const correctionRoundKey = `${name}CorrectRound`;
+        const inputKey = `${name}Inputs`;
+        const readSdk = (ctx) => sdkLocals(ctx.lane.resume.locals);
+        const writeSdk = (ctx, patch) => { const locals = ctx.lane.resume.locals; const base = locals && typeof locals === 'object' && !Array.isArray(locals) ? locals : {}; return { ...base, $sdk: { ...readSdk(ctx), ...patch } }; };
+        const fail = (runtimeError, ctx) => options.onError ? { next: options.onError(runtimeError, ctx) } : (() => { throw Object.assign(new Error(runtimeError.message), runtimeError); })();
+        const retryPolicy = options.retryPolicy;
+        const requirements = { ...(options.requirements ?? {}) };
+        this.handlers.set(name, (ctx) => {
+            const instruction = boundedInstruction(typeof options.instruction === 'string' ? options.instruction : options.instruction({ goal: ctx.goal, state: scalarProjection(ctx.laneState) }));
+            const inputs = options.inputs?.(ctx) ?? {};
+            const inputResultRefs = [...new Set([...(inputs.results ?? []), ...(inputs.findings ?? [])])];
+            const inputArtifactRefs = [...new Set(inputs.artifacts ?? [])];
+            const outputSchema = zodJsonSchema(options.schema);
+            const derivedFrom = [...inputResultRefs, ...inputArtifactRefs.map((ref) => ({ kind: 'artifact', ref }))];
+            return { actions: [{ type: 'submit_effects', effects: [{ key: `${name}-llm`, kind: 'llm', concurrencyClass: 'llm', input: programLLMInput(this.config, { task: options.task, instruction, inputs: asJson(inputs), outputSchema, requirements: { ...requirements, structuredOutput: { schema: outputSchema } }, ...(options.executionPolicy === undefined ? {} : { executionPolicy: options.executionPolicy }) }), ...(retryPolicy === undefined ? {} : { retryPolicy }), ...(derivedFrom.length ? { derivedFrom } : {}) }], wait: { onUnsatisfied: 'resume_with_error' } }], next: decode, locals: writeSdk(ctx, { [correctionRoundKey]: 0, [inputKey]: asJson(inputs) }) };
+        });
+        this.handlers.set(submit, (ctx) => ({ next: decode }));
+        this.handlers.set(decode, (ctx) => {
+            const dependencyError = waitFailure(ctx);
+            if (dependencyError)
+                return fail(dependencyError, ctx);
+            const input = ctx.resumeInput?.type === 'wait' ? Object.values(ctx.resumeInput.resolution.dependencies).find((dependency) => dependency.state !== 'pending') : undefined;
+            const ref = input?.state === 'settled' ? input.outcome.resultRef : undefined;
+            const rejectedRef = input?.state === 'settled' ? input.outcome.rejectedOutputRefs?.[0] : undefined;
+            const value = rejectedRef ? readResult(ctx, rejectedRef) : ref ? readResult(ctx, ref) : undefined;
+            const parsed = options.schema.safeParse(value);
+            if (!parsed.success) {
+                const sdk = readSdk(ctx);
+                const currentRound = typeof sdk[correctionRoundKey] === 'number' && Number.isInteger(sdk[correctionRoundKey]) ? sdk[correctionRoundKey] : 0;
+                if (currentRound >= maxCorrectionRounds)
+                    return fail({ code: 'OUTPUT_SCHEMA_VIOLATION', message: 'Structured LLM output did not match the declared schema.', retryable: false, details: parsed.error.message }, ctx);
+                const originalInputs = sdk[inputKey] && typeof sdk[inputKey] === 'object' && !Array.isArray(sdk[inputKey]) ? sdk[inputKey] : {};
+                const inputResultRefs = [...new Set([...(Array.isArray(originalInputs.results) ? originalInputs.results.filter((item) => typeof item === 'string') : []), ...(Array.isArray(originalInputs.findings) ? originalInputs.findings.filter((item) => typeof item === 'string') : []), ...(rejectedRef ? [rejectedRef] : [])])];
+                const inputArtifactRefs = [...new Set(Array.isArray(originalInputs.artifacts) ? originalInputs.artifacts.filter((item) => typeof item === 'string') : [])];
+                const correctionDerivedFrom = [...inputResultRefs, ...inputArtifactRefs.map((ref) => ({ kind: 'artifact', ref }))];
+                const outputSchema = zodJsonSchema(options.schema);
+                const correctionInstruction = boundedInstruction(`${typeof options.instruction === 'string' ? options.instruction : 'structured'}\nValidation errors: ${parsed.error.message}`);
+                return { actions: [{ type: 'submit_effects', effects: [{ key: `${name}-correct-${currentRound + 1}`, kind: 'llm', concurrencyClass: 'llm', input: programLLMInput(this.config, { task: options.task, instruction: correctionInstruction, inputs: { ...originalInputs, rejectedOutputRefs: inputResultRefs }, outputSchema, requirements: { ...requirements, structuredOutput: { schema: outputSchema } }, ...(options.executionPolicy === undefined ? {} : { executionPolicy: options.executionPolicy }) }), ...(retryPolicy === undefined ? {} : { retryPolicy }), ...(correctionDerivedFrom.length ? { derivedFrom: correctionDerivedFrom } : {}) }], wait: { onUnsatisfied: 'resume_with_error' } }], next: decode, locals: writeSdk(ctx, { [correctionRoundKey]: currentRound + 1, [inputKey]: { ...originalInputs, rejectedOutputRefs: inputResultRefs } }) };
+            }
+            const next = options.onSuccess(parsed.data, ctx);
+            return { next };
+        });
+        return this;
+    }
+    addReActLoopStep(name, options) {
+        this.compactionBoundaries.add(name);
+        const readTurns = (ctx) => { const sdk = sdkLocals(ctx.lane.resume.locals); const turn = sdk[`${name}Turns`]; return typeof turn === 'number' && Number.isInteger(turn) && turn >= 0 ? turn : 0; };
+        const inputKey = `${name}Inputs`;
+        const readInputs = (ctx) => { const value = sdkLocals(ctx.lane.resume.locals)[inputKey]; return value && typeof value === 'object' && !Array.isArray(value) ? value : {}; };
+        const writeTurns = (ctx, turns, inputs = readInputs(ctx)) => { const locals = ctx.lane.resume.locals; const base = locals && typeof locals === 'object' && !Array.isArray(locals) ? locals : {}; return { ...base, $sdk: { ...sdkLocals(locals), [`${name}Turns`]: turns, [inputKey]: asJson(inputs) } }; };
+        const resultRefFromWait = (ctx) => { const dependency = ctx.resumeInput?.type === 'wait' ? Object.values(ctx.resumeInput.resolution.dependencies)[0] : undefined; return dependency?.state === 'settled' ? dependency.outcome.resultRef : undefined; };
+        const resultRefsFromWait = (ctx) => ctx.resumeInput?.type === 'wait' ? Object.values(ctx.resumeInput.resolution.dependencies).flatMap((dependency) => dependency.state === 'settled' && dependency.outcome.resultRef ? [dependency.outcome.resultRef] : []) : [];
+        const instruction = (ctx) => boundedInstruction(typeof options.instruction === 'string' ? options.instruction : options.instruction({ goal: ctx.goal, state: scalarProjection(ctx.laneState) }));
+        const submitModel = (ctx, turn, inputs = {}) => { const resultRefs = [...new Set(inputs.results ?? [])]; const findingRefs = [...new Set(inputs.findings ?? [])]; const artifactRefs = [...new Set(inputs.artifacts ?? [])]; const dataRefs = [...resultRefs, ...findingRefs, ...artifactRefs.map((ref) => ({ kind: 'artifact', ref }))]; const requirements = { ...(options.requirements ?? {}), ...(options.toolAllow === undefined ? {} : { toolCalling: true }) }; return { actions: [{ type: 'submit_effects', effects: [{ key: `${name}-turn-${turn}`, kind: 'llm', concurrencyClass: 'llm', input: programLLMInput(this.config, { task: options.task ?? 'reason', instruction: instruction(ctx), inputs: { ...(resultRefs.length ? { results: resultRefs } : {}), ...(findingRefs.length ? { findings: findingRefs } : {}), ...(artifactRefs.length ? { artifacts: artifactRefs } : {}), ...(inputs.events?.length ? { events: [...new Set(inputs.events)] } : {}) }, turn, ...(options.outputSchema === undefined ? {} : { outputSchema: zodJsonSchema(options.outputSchema) }), ...(Object.keys(requirements).length ? { requirements } : {}) }), ...(dataRefs.length ? { derivedFrom: dataRefs } : {}) }], wait: { onUnsatisfied: 'resume_with_error' } }], next: { programId: this.config.id, programVersion: this.config.version, step: `${name}:decode`, locals: writeTurns(ctx, turn, inputs) }, locals: writeTurns(ctx, turn, inputs) }; };
+        this.handlers.set(name, (ctx) => { const turn = readTurns(ctx) + 1; const inputs = options.inputs?.(ctx) ?? {}; const output = submitModel(ctx, turn, inputs); return { ...output, next: `${name}:decode` }; });
+        this.handlers.set(`${name}:tools`, (ctx) => { const turn = readTurns(ctx); const previous = readInputs(ctx); const inputs = { ...previous, results: [...new Set([...(previous.results ?? []), ...resultRefsFromWait(ctx)])] }; return { ...submitModel(ctx, turn + 1, inputs), next: `${name}:decode` }; });
+        this.handlers.set(`${name}:decode`, (ctx) => {
+            const turns = readTurns(ctx);
+            const ref = resultRefFromWait(ctx);
+            const value = ref ? readResult(ctx, ref) ?? null : null;
+            const record = value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+            const finishReason = record?.finishReason;
+            const toolCalls = Array.isArray(record?.toolCalls) ? record.toolCalls : [];
+            const fail = (runtimeError) => options.onError ? { next: options.onError(runtimeError, ctx) } : (() => { const error = Object.assign(new Error(runtimeError.message), runtimeError); throw error; })();
+            const dependencyError = waitFailure(ctx);
+            if (dependencyError)
+                return fail(dependencyError);
+            const maxTurns = Math.max(1, Math.floor(options.maxTurns ?? 10));
+            const maxTurnsReached = () => options.onMaxTurns ? { next: options.onMaxTurns(ctx) } : fail({ code: 'MAX_TURNS_REACHED', message: `ReAct loop ${name} reached its maximum of ${maxTurns} turns.`, retryable: false });
+            if (finishReason === 'tool_calls') {
+                if (turns >= maxTurns || toolCalls.length === 0)
+                    return maxTurnsReached();
+                const invalidTool = toolCalls.find((call) => { const item = call && typeof call === 'object' && !Array.isArray(call) ? call : {}; const toolName = typeof item.name === 'string' ? item.name : ''; return !toolName || (options.toolAllow !== undefined && !options.toolAllow.includes(toolName)); });
+                if (invalidTool !== undefined)
+                    return fail({ code: 'ACTION_TOOL_NOT_ALLOWED', message: 'Model requested a tool outside the ReAct allow-list.', retryable: false });
+                const sourceEffectId = ctx.resumeInput?.type === 'wait' ? Object.values(ctx.resumeInput.resolution.dependencies).find((dependency) => dependency.state === 'settled' && dependency.target.kind === 'effect')?.target.id : undefined;
+                const sourcePrivacy = ref === undefined ? undefined : ctx.results.meta(ref)?.privacy;
+                const toolDerivedFrom = ref === undefined ? [] : [ref];
+                const calls = toolCalls.map((call, index) => {
+                    const item = call && typeof call === 'object' && !Array.isArray(call) ? call : {};
+                    const originalId = typeof item.toolCallId === 'string' ? item.toolCallId : `call-${index + 1}`;
+                    const toolName = typeof item.name === 'string' ? item.name : '';
+                    return { originalId, toolName, toolCallId: `${name}:${turns}:${originalId}`, input: item.input ?? {} };
+                });
+                const makeToolEffects = (approvedCalls) => ({ type: 'submit_effects', effects: approvedCalls.map((call, index) => ({ key: `${name}-tool-${turns}-${index + 1}`, toolCallId: String(call.toolCallId ?? `${name}:${turns}:${String(call.originalId)}`), ...(sourceEffectId === undefined ? {} : { llmEffectId: sourceEffectId }), ...(sourcePrivacy === undefined ? {} : { privacy: sourcePrivacy }), ...(toolDerivedFrom.length ? { derivedFrom: [...toolDerivedFrom] } : {}), kind: 'tool', concurrencyClass: 'tool', input: { toolCallId: String(call.toolCallId ?? `${name}:${turns}:${String(call.originalId)}`), name: String(call.toolName), arguments: call.input, ...(sourcePrivacy === undefined ? {} : { privacy: sourcePrivacy }), ...(toolDerivedFrom.length ? { derivedFrom: [...toolDerivedFrom] } : {}) } })), wait: { onUnsatisfied: 'resume_with_error' } });
+                if (options.toolApproval) {
+                    const approvalKey = `${name}PendingToolCalls`;
+                    const digestKey = `${name}PendingToolDigest`;
+                    const locals = ctx.lane.resume.locals && typeof ctx.lane.resume.locals === 'object' && !Array.isArray(ctx.lane.resume.locals) ? ctx.lane.resume.locals : {};
+                    const digest = contentHash(calls);
+                    const listing = calls.map((call, index) => `${index + 1}. ${call.toolName} ${call.toolCallId}`).join('\n');
+                    const extra = typeof options.toolApproval.prompt === 'string' ? options.toolApproval.prompt : options.toolApproval.prompt(calls.map((call) => ({ name: call.toolName, toolCallId: call.originalId })), ctx);
+                    const prompt = boundedInstruction(`Approve ${calls.length} tool call(s). Digest ${digest}.\n${listing}\n${extra}`);
+                    this.handlers.set(`${name}:approval`, (approvalCtx) => {
+                        const dependency = approvalCtx.resumeInput?.type === 'wait' ? Object.values(approvalCtx.resumeInput.resolution.dependencies)[0] : undefined;
+                        const approvalError = waitFailure(approvalCtx);
+                        if (approvalError)
+                            return fail(approvalError);
+                        if (dependency?.state !== 'settled')
+                            return fail({ code: 'APPROVAL_RESPONSE_MISSING', message: 'Approval response was not received.', retryable: false });
+                        const value = dependency.outcome.resultRef ? readResult(approvalCtx, dependency.outcome.resultRef) : undefined;
+                        const parsed = z.object({ approved: z.boolean(), reason: z.string().optional() }).safeParse(value);
+                        if (!parsed.success)
+                            return fail({ code: 'APPROVAL_RESPONSE_INVALID', message: 'Approval response must contain approved=true or false.', retryable: false, details: parsed.error.message });
+                        if (!parsed.data.approved) {
+                            const reason = parsed.data.reason ?? 'User denied the proposed tool call.';
+                            if (options.toolApproval?.onDenied)
+                                return { next: options.toolApproval.onDenied(reason, approvalCtx) };
+                            return fail({ code: 'APPROVAL_DENIED', message: reason, retryable: false });
+                        }
+                        const pendingLocals = sdkLocals(approvalCtx.lane.resume.locals);
+                        const pending = pendingLocals[approvalKey];
+                        if (!Array.isArray(pending))
+                            return fail({ code: 'APPROVAL_CALLS_MISSING', message: 'Approved tool calls were not found in the persisted lane state.', retryable: false });
+                        if (pendingLocals[digestKey] !== contentHash(pending))
+                            return fail({ code: 'APPROVAL_DIGEST_MISMATCH', message: 'Persisted tool calls no longer match the approved digest.', retryable: false });
+                        const approvedCalls = pending.flatMap((item) => item && typeof item === 'object' && !Array.isArray(item) ? [{ originalId: item.originalId ?? '', toolName: item.toolName ?? '', toolCallId: item.toolCallId ?? '', input: item.input ?? {} }] : []);
+                        const cleared = { ...locals, $sdk: { ...pendingLocals, [approvalKey]: null, [digestKey]: null } };
+                        return { actions: [makeToolEffects(approvedCalls)], next: `${name}:tools`, locals: cleared };
+                    });
+                    return { actions: [{ type: 'submit_effects', effects: [{ key: `${name}-approval-${turns}`, kind: 'human', concurrencyClass: 'none', input: { prompt, digest, tools: calls }, ...(toolDerivedFrom.length ? { derivedFrom: [...toolDerivedFrom] } : {}) }], wait: { onUnsatisfied: 'resume_with_error' } }], next: `${name}:approval`, locals: { ...locals, $sdk: { ...sdkLocals(locals), [approvalKey]: calls, [digestKey]: digest } } };
+                }
+                return { actions: [makeToolEffects(calls)], next: `${name}:tools` };
+            }
+            if (turns >= maxTurns)
+                return maxTurnsReached();
+            if (options.outputSchema) {
+                const outputValue = record?.structured === undefined ? value : record.structured;
+                const parsed = options.outputSchema.safeParse(outputValue);
+                if (!parsed.success)
+                    return fail({ code: 'OUTPUT_SCHEMA_VIOLATION', message: 'ReAct result did not match outputSchema.', retryable: false, details: parsed.error.message });
+            }
+            if (!ref)
+                return fail({ code: 'MISSING_RESULT_REF', message: 'ReAct result did not produce a ResultRef.', retryable: false });
+            if (typeof options.onFinish === 'function')
+                return { next: options.onFinish(ref, ctx) };
+            if (options.onFinish.structured) {
+                const structuredValue = record?.structured ?? value;
+                const parsed = options.onFinish.structured.schema.safeParse(structuredValue);
+                if (!parsed.success)
+                    return fail({ code: 'OUTPUT_SCHEMA_VIOLATION', message: 'ReAct structured result did not match schema.', retryable: false, details: parsed.error.message });
+                return { next: options.onFinish.structured.onParsed(parsed.data, ctx) };
+            }
+            return { next: options.onFinish.text(ref, ctx) };
+        });
+        return this;
+    }
+    addParallelStep(name, options) {
+        this.compactionBoundaries.add(name);
+        const joinStep = `${name}:join`;
+        this.handlers.set(name, (ctx) => {
+            const join = joinOptions(options.join, options);
+            const rawLanes = Object.entries(options.lanes).map(([key, lane]) => { const dependsOn = normalizeDependsOn(lane.dependsOn); return { key, goal: lane.goal, program: { programId: lane.program.programId, programVersion: lane.program.programVersion, step: lane.program.step ?? 'start', locals: lane.program.locals ?? {} }, ...(lane.priority === undefined ? {} : { priority: lane.priority }), ...(lane.contextVersion === undefined ? {} : { contextVersion: lane.contextVersion }), ...(lane.affinityKey === undefined ? {} : { affinityKey: lane.affinityKey }), ...(lane.resources === undefined ? {} : { resources: lane.resources }), ...(lane.inputResultRefs === undefined ? {} : { inputResultRefs: lane.inputResultRefs }), ...(dependsOn === undefined ? {} : { dependsOn }) }; });
+            const collapsed = collapseAffinityLanes(name, rawLanes, affinityAdvice(ctx) ?? [], options.affinity !== 'ack', join.mode, join.condition);
+            const action = { type: 'fork', affinityAck: options.affinity === 'ack' || affinityAdvice(ctx) !== undefined, lanes: collapsed.lanes, ...(collapsed.aliases === undefined ? {} : { joinAliases: collapsed.aliases }), join };
+            return { actions: [action], next: options.onJoin ? joinStep : options.next ?? joinStep };
+        });
+        if (options.onJoin)
+            this.handlers.set(joinStep, (ctx) => { const outcomes = {}; if (ctx.resumeInput?.type === 'wait')
+                for (const [key, dependency] of Object.entries(ctx.resumeInput.resolution.dependencies))
+                    if (dependency.state !== 'pending')
+                        outcomes[key] = joinedOutcome(ctx, dependency, key); return { next: options.onJoin(outcomes, ctx) }; });
+        return this;
+    }
+    addDynamicForkStep(name, options) {
+        this.compactionBoundaries.add(name);
+        const joinStep = `${name}:join`;
+        this.handlers.set(name, (ctx) => {
+            const join = joinOptions(options.join, options);
+            const proposal = options.proposal?.(ctx) ?? { lanes: options.lanes?.(ctx) ?? {} };
+            const rawLanes = Object.entries(proposal.lanes).map(([key, lane]) => { const dependsOn = normalizeDependsOn(lane.dependsOn); return { key, goal: lane.goal, program: { programId: lane.program.programId, programVersion: lane.program.programVersion, step: lane.program.step ?? 'start', locals: lane.program.locals ?? {} }, ...(lane.priority === undefined ? {} : { priority: lane.priority }), ...(lane.contextVersion === undefined ? {} : { contextVersion: lane.contextVersion }), ...(lane.affinityKey === undefined ? {} : { affinityKey: lane.affinityKey }), ...(lane.resources === undefined ? {} : { resources: lane.resources }), ...(lane.inputResultRefs === undefined ? {} : { inputResultRefs: lane.inputResultRefs }), ...(dependsOn === undefined ? {} : { dependsOn }) }; });
+            const advice = affinityAdvice(ctx) ?? [];
+            const affinity = typeof options.affinity === 'function' ? options.affinity(advice, ctx) : options.affinity;
+            const collapsed = collapseAffinityLanes(name, rawLanes, advice, affinity !== 'ack', join.mode, join.condition);
+            const action = { type: 'fork', affinityAck: affinity === 'ack' || advice.length > 0, lanes: collapsed.lanes, ...(collapsed.aliases === undefined ? {} : { joinAliases: collapsed.aliases }), join };
+            return { actions: [action], next: options.onJoin ? joinStep : options.next ?? joinStep };
+        });
+        if (options.onJoin)
+            this.handlers.set(joinStep, (ctx) => { const outcomes = new Map(); if (ctx.resumeInput?.type === 'wait')
+                for (const [key, dependency] of Object.entries(ctx.resumeInput.resolution.dependencies))
+                    if (dependency.state !== 'pending')
+                        outcomes.set(key, joinedOutcome(ctx, dependency, key)); return { next: options.onJoin(outcomes, ctx) }; });
+        return this;
+    }
+    addMergeStep(name, options) {
+        this.compactionBoundaries.add(name);
+        this.handlers.set(name, (ctx) => {
+            const dependencies = ctx.resumeInput?.type === 'wait' ? Object.values(ctx.resumeInput.resolution.dependencies) : [];
+            const joinedLaneIds = new Set(dependencies.filter((dependency) => dependency.target.kind === 'lane').map((dependency) => dependency.target.id));
+            const outcomeSource = options.sources?.outcomes;
+            const joined = dependencies.flatMap((dependency) => dependency.state === 'settled' && dependency.outcome.resultRef && (outcomeSource === undefined || outcomeSource === 'joined' || outcomeSource.includes(dependency.target.id)) ? [dependency.outcome.resultRef] : []);
+            const proposalSource = options.sources?.proposals;
+            const proposals = ctx.mergeProposals.filter((proposal) => proposalSource === undefined || (proposalSource === 'joined' ? joinedLaneIds.has(proposal.sourceLaneId) : proposalSource.includes(proposal.sourceLaneId)));
+            const instruction = options.instruction === undefined ? undefined : boundedInstruction(typeof options.instruction === 'string' ? options.instruction : options.instruction(ctx));
+            return { actions: [{ type: 'submit_effects', effects: [{ key: `${name}-llm`, kind: 'llm', concurrencyClass: 'llm', input: programLLMInput(this.config, { task: options.task ?? 'reason', merge: true, sources: asJson(joined), proposals: asJson(proposals.map((proposal) => ({ id: proposal.id, sourceLaneId: proposal.sourceLaneId, delta: proposal.delta }))), ...(instruction === undefined ? {} : { instruction }) }), ...(joined.length ? { derivedFrom: joined } : {}) }], wait: { onUnsatisfied: 'resume_with_error' } }], next: `${name}:decode` };
+        });
+        this.handlers.set(`${name}:decode`, (ctx) => {
+            const dependency = ctx.resumeInput?.type === 'wait' ? Object.values(ctx.resumeInput.resolution.dependencies)[0] : undefined;
+            const ref = dependency?.state === 'settled' ? dependency.outcome.resultRef : undefined;
+            const value = ref ? readResult(ctx, ref) : undefined;
+            const fail = (runtimeError) => options.onError ? { next: options.onError(runtimeError, ctx) } : (() => { throw Object.assign(new Error(runtimeError.message), runtimeError); })();
+            const dependencyError = waitFailure(ctx);
+            if (dependencyError)
+                return fail(dependencyError);
+            if (options.schema) {
+                const parsed = options.schema.safeParse(value);
+                if (!parsed.success)
+                    return fail({ code: 'OUTPUT_SCHEMA_VIOLATION', message: 'Merge result did not match schema.', retryable: false, details: parsed.error.message });
+                const next = options.onSynthesized ? options.onSynthesized(parsed.data, ctx) : options.next;
+                if (!next)
+                    return fail({ code: 'MERGE_TARGET_MISSING', message: 'Merge step requires onSynthesized or next.', retryable: false });
+                return { next };
+            }
+            const next = options.onSynthesized ? options.onSynthesized(value, ctx) : options.next;
+            if (!next)
+                return fail({ code: 'MERGE_TARGET_MISSING', message: 'Merge step requires onSynthesized or next.', retryable: false });
+            return { next };
+        });
+        return this;
+    }
+    addWaitStep(name, spec) {
+        this.compactionBoundaries.add(name);
+        if ('dependencies' in spec) {
+            this.handlers.set(name, () => ({ actions: [{ type: 'wait', spec: { ...spec, mode: spec.mode ?? 'all', ...(spec.quorum === undefined ? {} : { quorum: spec.quorum }), ...(spec.deadlineAt === undefined ? {} : { deadlineAt: spec.deadlineAt }), onUnsatisfied: 'resume_with_error', reason: 'dependency' } }], next: spec.next }));
+            return this;
+        }
+        const resume = `${name}:resume`;
+        this.handlers.set(name, (ctx) => ({ actions: [{ type: 'wait', spec: { dependencies: spec.targets(ctx), mode: spec.mode ?? 'all', ...(spec.quorum === undefined ? {} : { quorum: spec.quorum }), ...(spec.timeoutMs === undefined ? {} : { deadlineAt: ctx.now + Math.max(0, spec.timeoutMs) }), onUnsatisfied: 'resume_with_error', reason: 'dependency' } }], next: resume }));
+        this.handlers.set(resume, (ctx) => {
+            const resolution = ctx.resumeInput?.type === 'wait' ? ctx.resumeInput.resolution : undefined;
+            if (!resolution)
+                throw Object.assign(new Error('WAIT_RESOLUTION_MISSING'), { code: 'WAIT_RESOLUTION_MISSING', retryable: false });
+            if (resolution.status === 'satisfied')
+                return { next: spec.onResolved(resolution, ctx) };
+            if (spec.onUnsatisfied)
+                return { next: spec.onUnsatisfied(resolution, ctx) };
+            throw Object.assign(new Error(resolution.error?.message ?? 'WAIT_UNSATISFIED'), resolution.error ?? { code: 'WAIT_UNSATISFIED', retryable: false });
+        });
+        return this;
+    }
+    addHumanStep(name, options) {
+        this.compactionBoundaries.add(name);
+        const decode = `${name}:decode`;
+        this.handlers.set(name, (ctx) => { const prompt = boundedInstruction(typeof options.prompt === 'string' ? options.prompt : options.prompt({ goal: ctx.goal, state: scalarProjection(ctx.laneState) })); const inputs = options.inputs?.(ctx) ?? {}; const inputResultRefs = [...new Set([...(inputs.results ?? []), ...(inputs.findings ?? []), ...(inputs.artifacts ?? [])])]; return { actions: [{ type: 'submit_effects', effects: [{ key: `${name}-human`, kind: 'human', concurrencyClass: 'none', input: asJson({ prompt, inputs }), ...(inputResultRefs.length ? { derivedFrom: inputResultRefs } : {}), ...(options.timeoutMs === undefined ? {} : { attemptTimeoutMs: options.timeoutMs }) }], wait: { onUnsatisfied: 'resume_with_error' } }], next: decode }; });
+        this.handlers.set(decode, (ctx) => {
+            const dependency = ctx.resumeInput?.type === 'wait' ? Object.values(ctx.resumeInput.resolution.dependencies)[0] : undefined;
+            if (dependency?.state === 'settled') {
+                const runtimeError = dependency.outcome.error;
+                if (runtimeError) {
+                    if ((runtimeError.code === 'ATTEMPT_TIMEOUT' || runtimeError.code === 'TIMEOUT') && options.onTimeout)
+                        return { next: options.onTimeout(ctx) };
+                    throw Object.assign(new Error(runtimeError.message), runtimeError);
+                }
+                const ref = dependency.outcome.resultRef;
+                const value = ref ? readResult(ctx, ref) : undefined;
+                const parsed = options.schema.safeParse(value);
+                if (parsed.success)
+                    return { next: options.onReply(parsed.data, ctx) };
+                throw Object.assign(new Error('Human reply did not match schema.'), { code: 'HUMAN_RESPONSE_SCHEMA_VIOLATION', message: 'Human reply did not match schema.', retryable: false, details: parsed.error.message });
+            }
+            if (dependency?.state === 'pending')
+                throw Object.assign(new Error('Human response is still pending.'), { code: 'HUMAN_RESPONSE_PENDING', message: 'Human response is still pending.', retryable: false });
+            if (ctx.resumeInput?.type === 'wait')
+                throw Object.assign(new Error(ctx.resumeInput.resolution.error?.message ?? 'Human response was not received.'), ctx.resumeInput.resolution.error ?? { code: 'HUMAN_RESPONSE_UNSATISFIED', message: 'Human response was not received.', retryable: false });
+            throw Object.assign(new Error('Human response resolution is missing.'), { code: 'HUMAN_RESPONSE_MISSING', message: 'Human response resolution is missing.', retryable: false });
+        });
+        return this;
+    }
+    addTimerStep(name, options) {
+        this.compactionBoundaries.add(name);
+        const decode = `${name}:resume`;
+        this.handlers.set(name, (ctx) => ({ actions: [{ type: 'submit_effects', effects: [{ key: `${name}-timer`, kind: 'timer', concurrencyClass: 'none', input: { delayMs: typeof options.delayMs === 'number' ? options.delayMs : options.delayMs(ctx) } }], wait: { onUnsatisfied: 'resume_with_error' } }], next: decode }));
+        this.handlers.set(decode, (ctx) => {
+            const resolution = ctx.resumeInput?.type === 'wait' ? ctx.resumeInput.resolution : undefined;
+            const dependency = resolution ? Object.values(resolution.dependencies)[0] : undefined;
+            const runtimeError = dependency?.state === 'settled' ? dependency.outcome.error : undefined;
+            if (resolution?.status === 'satisfied' && runtimeError === undefined)
+                return { next: options.onFire(ctx) };
+            throw Object.assign(new Error(runtimeError?.message ?? resolution?.error?.message ?? 'Timer did not fire.'), runtimeError ?? resolution?.error ?? { code: 'TIMER_NOT_FIRED', message: 'Timer did not fire.', retryable: false });
+        });
+        return this;
+    }
+    build(entry = this.handlers.has('start') ? 'start' : [...this.handlers.keys()][0] ?? 'start') {
+        if (!this.handlers.has(entry))
+            this.handlers.set(entry, () => ({ actions: [{ type: 'complete', result: { ok: true } }], next: entry }));
+        const compaction = this.config.historyCompaction;
+        const compactSummarize = '$compact:summarize';
+        const compactApply = '$compact:apply';
+        if (compaction) {
+            const keepRecentRounds = Math.max(0, Math.floor(compaction.keepRecentRounds));
+            this.handlers.set(compactSummarize, (ctx) => {
+                const candidates = ctx.history.slice(0, Math.max(0, ctx.history.length - keepRecentRounds));
+                const upToSeq = candidates.at(-1)?.seq;
+                const locals = ordinaryLocals(ctx.lane.resume.locals);
+                const sdk = sdkLocals(ctx.lane.resume.locals);
+                const returnStep = typeof sdk.compactReturnStep === 'string' ? sdk.compactReturnStep : ctx.lane.resume.step;
+                if (upToSeq === undefined)
+                    return { next: returnStep === compactSummarize ? entry : returnStep, locals: { ...locals, $sdk: sdk } };
+                return {
+                    actions: [{ type: 'submit_effects', effects: [{ key: '$compact-summary', kind: 'llm', concurrencyClass: 'llm', input: programLLMInput(this.config, { task: compaction.summarizeTask, historySeqs: candidates.map((record) => record.seq), upToSeq }) }], wait: { onUnsatisfied: 'resume_with_error' } }],
+                    next: compactApply,
+                    locals: { ...locals, $sdk: { ...sdk, compactPending: true, compactReturnStep: returnStep, compactUpToSeq: upToSeq } },
+                };
+            });
+            this.handlers.set(compactApply, (ctx) => {
+                const sdk = sdkLocals(ctx.lane.resume.locals);
+                const resolution = ctx.resumeInput?.type === 'wait' ? ctx.resumeInput.resolution : undefined;
+                const dependency = resolution ? Object.values(resolution.dependencies).find((item) => item.state === 'settled') : undefined;
+                const runtimeError = dependency?.state === 'settled' ? dependency.outcome.error : undefined;
+                if (runtimeError || resolution?.status !== 'satisfied') {
+                    const error = runtimeError ?? resolution?.error ?? { code: 'HISTORY_COMPACTION_FAILED', message: 'History compaction did not produce a summary.', retryable: false };
+                    throw Object.assign(new Error(error.message), error);
+                }
+                const summaryRef = dependency?.state === 'settled' ? dependency.outcome.resultRef : undefined;
+                const returnStep = typeof sdk.compactReturnStep === 'string' ? sdk.compactReturnStep : entry;
+                const upToSeq = typeof sdk.compactUpToSeq === 'number' ? sdk.compactUpToSeq : undefined;
+                const base = ordinaryLocals(ctx.lane.resume.locals);
+                const nextSdk = { ...sdk };
+                delete nextSdk.compactPending;
+                delete nextSdk.compactReturnStep;
+                delete nextSdk.compactUpToSeq;
+                if (!summaryRef || upToSeq === undefined)
+                    return { next: returnStep, locals: { ...base, $sdk: nextSdk } };
+                return { contextDelta: { target: 'lane', baseVersion: ctx.lane.context.version, ops: [{ op: 'compact_history', upToSeq, summaryRef }] }, next: returnStep, locals: { ...base, $sdk: nextSdk } };
+            });
+        }
+        const definition = {
+            id: this.config.id,
+            version: this.config.version,
+            entry,
+            steps: [...this.handlers.keys()],
+            debugSources: [...this.handlers.values()].map((handler) => handler.toString()),
+            ...(this.config.system === undefined ? {} : { system: this.config.system }),
+            ...(this.config.toolSet === undefined ? {} : { toolSet: this.config.toolSet }),
+            step: (context) => {
+                const sdk = sdkLocals(context.lane.resume.locals);
+                const pressure = context.lane.historyPressure;
+                const shouldCompact = compaction !== undefined && this.compactionBoundaries.has(context.lane.resume.step) && !context.lane.resume.step.startsWith('$compact:') && context.lane.activeWaitId === undefined && sdk.compactPending !== true && pressure !== undefined && pressure.historyTokens > pressure.softTokens && context.lane.context.history.length > Math.max(0, Math.floor(compaction.keepRecentRounds));
+                if (shouldCompact)
+                    return { actions: [], next: { programId: this.config.id, programVersion: this.config.version, step: compactSummarize, locals: { ...ordinaryLocals(context.lane.resume.locals), $sdk: { ...sdk, compactPending: true, compactReturnStep: context.lane.resume.step } } } };
+                const requestedStep = shouldCompact ? compactSummarize : context.lane.resume.step;
+                const handler = this.handlers.get(requestedStep) ?? this.handlers.get(entry);
+                const state = this.config.state ? this.config.state.parse(context.lane.context.state) : context.lane.context.state;
+                const { ctx, getDelta, getActions, getDerivedRefs, getAdoptImmediately } = makeContext(context, state);
+                const result = handler(ctx);
+                const derivedFrom = getDerivedRefs();
+                const delta = result.contextDelta ?? getDelta();
+                const derivedDelta = delta && delta.derivedFrom === undefined && derivedFrom.length ? { ...delta, derivedFrom } : delta;
+                const mergedDelta = derivedDelta && derivedFrom.length ? { ...derivedDelta, derivedFrom: [...new Set([...derivedFrom, ...(derivedDelta.derivedFrom ?? [])])] } : derivedDelta;
+                const destination = target(result.next, context.lane.resume.step);
+                const actions = [...getActions(), ...(result.actions ?? []), ...(destination.action === undefined ? [] : [destination.action])].map((action) => annotateAction(action, derivedFrom));
+                return { actions, next: { programId: this.config.id, programVersion: this.config.version, step: destination.step, locals: result.locals ?? ctx.lane.resume.locals }, ...(mergedDelta ? { contextDelta: mergedDelta } : {}), ...((result.adoptCommittedContext || getAdoptImmediately()) ? { adoptCommittedContext: true } : {}) };
+            },
+            ...(this.boundaryHandler === undefined ? {} : { errorBoundary: (error, context) => { const state = this.config.state ? this.config.state.parse(context.lane.context.state) : context.lane.context.state; const { ctx, getDelta, getActions, getDerivedRefs, getAdoptImmediately } = makeContext(context, state); const result = this.boundaryHandler(error, ctx); const derivedFrom = getDerivedRefs(); const delta = getDelta(); const mergedDelta = delta && derivedFrom.length ? { ...delta, derivedFrom: [...new Set([...derivedFrom, ...(delta.derivedFrom ?? [])])] } : delta; const destination = target(result, context.lane.resume.step); const actions = [...getActions(), ...(destination.action === undefined ? [] : [destination.action])].map((action) => annotateAction(action, derivedFrom)); return { actions, next: { programId: this.config.id, programVersion: this.config.version, step: destination.step, locals: context.lane.resume.locals }, ...(mergedDelta ? { contextDelta: mergedDelta } : {}), ...(getAdoptImmediately() ? { adoptCommittedContext: true } : {}) }; } })
+        };
+        return definition;
+    }
+}
+export function defineLaneProgram(config, define) { const builder = new StepBuilder(config); define(builder); return builder.build(); }
+function pureStepViolation(api) {
+    throw Object.assign(new Error(`Pure Step attempted to access ${api}. Use StepContext.now or ctx.trace().`), { code: 'PURE_STEP_VIOLATION' });
+}
+function patchGlobalValue(target, key, value) {
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    try {
+        const replacement = descriptor !== undefined && ('get' in descriptor || 'set' in descriptor)
+            ? { configurable: descriptor.configurable ?? false, enumerable: descriptor.enumerable ?? false, writable: true, value }
+            : descriptor === undefined ? { configurable: true, enumerable: true, writable: true, value } : { configurable: descriptor.configurable ?? false, enumerable: descriptor.enumerable ?? false, writable: true, value };
+        Object.defineProperty(target, key, replacement);
+        return () => {
+            try {
+                if (descriptor === undefined)
+                    delete target[key];
+                else
+                    Object.defineProperty(target, key, descriptor);
+            }
+            catch { /* best-effort restoration after a synchronous Step */ }
+        };
+    }
+    catch {
+        return () => undefined;
+    }
+}
+/** Run a synchronous Step inside the development-only impurity boundary. */
+export function withPureStepGuard(callback) {
+    const environment = typeof process === 'undefined' ? undefined : process.env.NODE_ENV;
+    if (environment === 'production')
+        return callback();
+    const restores = [];
+    const violation = (api) => pureStepViolation(api);
+    const globalObject = globalThis;
+    const math = globalObject.Math;
+    if (math)
+        restores.push(patchGlobalValue(math, 'random', () => violation('Math.random')));
+    const date = globalObject.Date;
+    if (date)
+        restores.push(patchGlobalValue(date, 'now', () => violation('Date.now')));
+    if (typeof globalObject.fetch === 'function')
+        restores.push(patchGlobalValue(globalObject, 'fetch', () => violation('fetch')));
+    const consoleObject = globalObject.console;
+    if (consoleObject)
+        for (const method of ['debug', 'dir', 'error', 'info', 'log', 'trace', 'warn'])
+            if (typeof consoleObject[method] === 'function')
+                restores.push(patchGlobalValue(consoleObject, method, () => violation(`console.${method}`)));
+    const processObject = globalObject.process;
+    if (processObject && (typeof processObject === 'object' || typeof processObject === 'function')) {
+        try {
+            const guardedProcess = new Proxy(processObject, { get: () => violation('process'), set: () => violation('process') });
+            restores.push(patchGlobalValue(globalObject, 'process', guardedProcess));
+        }
+        catch { /* static purity checks still protect environments with an immutable process binding */ }
+    }
+    try {
+        return callback();
+    }
+    finally {
+        for (const restore of restores.reverse())
+            restore();
+    }
+}
+export function assertProgramPure(program) {
+    const candidate = program;
+    const source = [program.step.toString(), program.errorBoundary?.toString() ?? '', ...(candidate.debugSources ?? []), program.seriesMemberProgram?.step.toString() ?? '', program.seriesMemberProgram?.errorBoundary?.toString() ?? ''].join('\n');
+    for (const forbidden of ['Date.now(', 'Math.random(', 'fetch(', 'await '])
+        if (source.includes(forbidden))
+            throw new Error(`ASYNC_STEP_NOT_ALLOWED:${forbidden}`);
+    if ((candidate.steps ?? []).some((step) => step.includes('undefined')))
+        throw new Error('INVALID_STEP_NAME');
+}