@toolproof-core/lib 1.0.46 → 1.0.48

package/src/utils/mutableStrategyOverlay.ts

@@ -16,97 +16,87 @@ import type {
 } from '@toolproof-core/genesis';
 import { extractResourceTypeHandleFromRoleValue } from './strategyExtraction.js';
 
-export type MutableToolStepKey = string;
-export type MutableBranchStepKey = string;
-export type MutableWhileStepKey = string;
-export type MutableForStepKey = string;
+export type MutableToolStepKey = `TOOL_STEP-${string}`;
+export type MutableBranchStepKey = `BRANCH_STEP-${string}`;
+export type MutableWhileStepKey = `WHILE_STEP-${string}`;
+export type MutableForStepKey = `FOR_STEP-${string}`;
 export type MutableLoopStepKey = MutableWhileStepKey | MutableForStepKey;
 export type MutableMacroStepKey = MutableBranchStepKey | MutableLoopStepKey;
+export type MutableStepKey = MutableToolStepKey | MutableMacroStepKey;
 
 export type MutableMaterializedResource = MaterializedResource;
 
-export type MutableToolStepRoleAddress<TKey extends string = MutableToolStepKey> =
+export type MutableToolStepRoleAddress =
     Omit<ToolStepRoleAddress, 'toolStepPath'> & {
-        toolStepKey: TKey;
+        stepKey: MutableToolStepKey;
+        toolStepKey: MutableToolStepKey;
     };
 
-export type MutableInternalInputPotential<TKey extends string = MutableToolStepKey> =
+export type MutableInternalInputPotential =
     Omit<InternalInputPotential, 'toolStepRoleAddress'> & {
-        toolStepRoleAddress: MutableToolStepRoleAddress<TKey>;
+        toolStepRoleAddress: MutableToolStepRoleAddress;
     };
 
 export type MutableExternalInputPotential = ExternalInputPotential;
 
-export type MutableStrategyStateEntry<TKey extends string = MutableToolStepKey> =
+export type MutableStrategyStateEntry =
     | MutableMaterializedResource
-    | MutableInternalInputPotential<TKey>
+    | MutableInternalInputPotential
     | MutableExternalInputPotential;
 
-export type MutableStrategyStateEntryByRoleName<
-    TKey extends string = MutableToolStepKey,
-> = Partial<Record<RoleName, MutableStrategyStateEntry<TKey>>>;
+export type MutableStrategyStateEntryByRoleName = Partial<Record<RoleName, MutableStrategyStateEntry>>;
 
-export type MutableStrategyState<
-    TKey extends string = MutableToolStepKey,
-> = Partial<Record<TKey, MutableStrategyStateEntryByRoleName<TKey>>>;
+export type MutableStrategyState = Partial<Record<MutableToolStepKey, MutableStrategyStateEntryByRoleName>>;
 
-export type MutableToolStep<TKey extends string = MutableToolStepKey> = ToolStep & {
-    toolStepKey: TKey;
+export type MutableToolStep = ToolStep & {
+    stepKey: MutableToolStepKey;
+    toolStepKey: MutableToolStepKey;
 };
 
-export type MutableCase<TKey extends string = MutableToolStepKey> = Omit<Case, 'when' | 'what'> & {
-    when: MutableToolStep<TKey>;
-    what: MutableToolStep<TKey>;
+export type MutableCase = Omit<Case, 'when' | 'what'> & {
+    when: MutableToolStep;
+    what: MutableToolStep;
 };
 
-export type MutableBranchStep<TKey extends string = MutableToolStepKey> = Omit<BranchStep, 'cases'> & {
+export type MutableBranchStep = Omit<BranchStep, 'cases'> & {
+    stepKey: MutableBranchStepKey;
     macroStepKey: MutableBranchStepKey;
-    cases: [MutableCase<TKey>, ...MutableCase<TKey>[]];
+    cases: [MutableCase, ...MutableCase[]];
 };
 
-export type MutableWhileStep<TKey extends string = MutableToolStepKey> = Omit<WhileStep, 'case'> & {
+export type MutableWhileStep = Omit<WhileStep, 'case'> & {
+    stepKey: MutableWhileStepKey;
     macroStepKey: MutableWhileStepKey;
-    case: MutableCase<TKey>;
+    case: MutableCase;
 };
 
-export type MutableForStep<TKey extends string = MutableToolStepKey> = Omit<ForStep, 'case'> & {
+export type MutableForStep = Omit<ForStep, 'case'> & {
+    stepKey: MutableForStepKey;
     macroStepKey: MutableForStepKey;
-    case: MutableCase<TKey>;
+    case: MutableCase;
 };
 
-export type MutableStep<TKey extends string = MutableToolStepKey> =
-    | MutableToolStep<TKey>
-    | MutableBranchStep<TKey>
-    | MutableWhileStep<TKey>
-    | MutableForStep<TKey>;
-
-export type MutableStrategy<
-    TKey extends string = MutableToolStepKey,
-    TStep extends MutableStep<TKey> = MutableStep<TKey>,
-    TState extends MutableStrategyState<TKey> = MutableStrategyState<TKey>,
-> = Omit<Strategy, 'stepsByThreadIndex' | 'strategyState'> & {
-    stepsByThreadIndex: TStep[][];
-    strategyState: TState;
+export type MutableStep =
+    | MutableToolStep
+    | MutableBranchStep
+    | MutableWhileStep
+    | MutableForStep;
+
+export type MutableStrategy = Omit<Strategy, 'stepsByThreadIndex' | 'strategyState'> & {
+    stepsByThreadIndex: MutableStep[][];
+    strategyState: MutableStrategyState;
 };
 
-export function getAuthoringSteps<
-    TKey extends string = MutableToolStepKey,
-    TStep extends MutableStep<TKey> = MutableStep<TKey>,
-    TState extends MutableStrategyState<TKey> = MutableStrategyState<TKey>,
->(
-    strategy: MutableStrategy<TKey, TStep, TState>,
-): TStep[] {
+export function getAuthoringSteps(
+    strategy: MutableStrategy,
+): MutableStep[] {
     return strategy.stepsByThreadIndex[0] ?? [];
 }
 
-export function setAuthoringSteps< // ATTENTION
-    TKey extends string = MutableToolStepKey,
-    TStep extends MutableStep<TKey> = MutableStep<TKey>,
-    TState extends MutableStrategyState<TKey> = MutableStrategyState<TKey>,
->(
-    strategy: MutableStrategy<TKey, TStep, TState>,
-    steps: TStep[],
-): MutableStrategy<TKey, TStep, TState> {
+export function setAuthoringSteps(
+    strategy: MutableStrategy,
+    steps: MutableStep[],
+): MutableStrategy {
     const nextStepsByThreadIndex = [...strategy.stepsByThreadIndex];
     nextStepsByThreadIndex[0] = steps;
 
@@ -116,26 +106,26 @@ export function setAuthoringSteps< // ATTENTION
     };
 }
 
-export function getStrategyStateEntryByRoleName<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
-    strategyState: TStrategyState,
-    toolStepKey: TKey,
-): MutableStrategyStateEntryByRoleName<TKey> | undefined {
+export function getStrategyStateEntryByRoleName(
+    strategyState: MutableStrategyState,
+    toolStepKey: MutableToolStepKey,
+): MutableStrategyStateEntryByRoleName | undefined {
     return strategyState[toolStepKey];
 }
 
-export function getStrategyStateEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
-    strategyState: TStrategyState,
-    toolStepRoleAddress: MutableToolStepRoleAddress<TKey>,
-): MutableStrategyStateEntry<TKey> | undefined {
+export function getStrategyStateEntry(
+    strategyState: MutableStrategyState,
+    toolStepRoleAddress: MutableToolStepRoleAddress,
+): MutableStrategyStateEntry | undefined {
     const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey);
     return inputEntryByRoleName?.[toolStepRoleAddress.roleName];
 }
 
-export function setStrategyStateEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
-    strategyState: TStrategyState,
-    toolStepRoleAddress: MutableToolStepRoleAddress<TKey>,
-    entry: MutableStrategyStateEntry<TKey>,
-): TStrategyState {
+export function setStrategyStateEntry(
+    strategyState: MutableStrategyState,
+    toolStepRoleAddress: MutableToolStepRoleAddress,
+    entry: MutableStrategyStateEntry,
+): MutableStrategyState {
     const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey) ?? {};
 
     return {
@@ -147,13 +137,10 @@ export function setStrategyStateEntry<TKey extends string, TStrategyState extend
     };
 }
 
-export function clearInputBinding<
-    TKey extends string,
-    TStrategyState extends MutableStrategyState<TKey>
->(
-    strategyState: TStrategyState,
-    toolStepRoleAddress: MutableToolStepRoleAddress<TKey>,
-): TStrategyState {
+export function clearInputBinding(
+    strategyState: MutableStrategyState,
+    toolStepRoleAddress: MutableToolStepRoleAddress,
+): MutableStrategyState {
     const inputEntryByRoleName =
         getStrategyStateEntryByRoleName(
             strategyState,
@@ -170,7 +157,7 @@ export function clearInputBinding<
     if (Object.keys(nextInputEntryByRoleName).length === 0) {
         const nextStrategyState = { ...strategyState };
         delete nextStrategyState[toolStepRoleAddress.toolStepKey];
-        return nextStrategyState as TStrategyState;
+        return nextStrategyState;
     }
 
     return {
@@ -179,11 +166,11 @@ export function clearInputBinding<
     };
 }
 
-export function bindMaterializedResource<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
-    strategyState: TStrategyState,
-    target: MutableToolStepRoleAddress<TKey>,
+export function bindMaterializedResource(
+    strategyState: MutableStrategyState,
+    target: MutableToolStepRoleAddress,
     resource: Resource,
-): TStrategyState { // ATTENTION: misleading name since it also materializes the Resource
+): MutableStrategyState { // ATTENTION: misleading name since it also materializes the Resource
     const mutableMaterializedResource: MutableMaterializedResource = {
         ...resource,
         strategyStateEntryKind: 'materializedResource',
@@ -200,15 +187,15 @@ function getOutputRoleValue(tool: Tool, roleName: RoleName) {
     return tool.roleSpec.outputRoleValueByName[roleName];
 }
 
-export function bindInternalInputPotential<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
-    strategyState: TStrategyState,
-    targetAddress: MutableToolStepRoleAddress<TKey>,
-    sourceAddress: MutableToolStepRoleAddress<TKey>,
+export function bindInternalInputPotential(
+    strategyState: MutableStrategyState,
+    targetAddress: MutableToolStepRoleAddress,
+    sourceAddress: MutableToolStepRoleAddress,
     context: {
-        toolStepByKey: ReadonlyMap<TKey, MutableToolStep<TKey>>;
+        toolStepByKey: ReadonlyMap<MutableToolStepKey, MutableToolStep>;
         toolMap: ReadonlyMap<ToolHandle, Tool>;
     }
-): TStrategyState {
+): MutableStrategyState {
 
     const sourceToolStep = context.toolStepByKey.get(sourceAddress.toolStepKey);
     if (!sourceToolStep) {
@@ -268,16 +255,17 @@ export function bindInternalInputPotential<TKey extends string, TStrategyState e
     return setStrategyStateEntry(strategyState, targetAddress, {
         strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
+            stepKey: sourceAddress.stepKey,
             toolStepKey: sourceAddress.toolStepKey,
             roleName: sourceAddress.roleName,
         },
     });
 }
 
-export function bindExternalInputPotential<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
-    strategyState: TStrategyState,
-    target: MutableToolStepRoleAddress<TKey>,
-): TStrategyState {
+export function bindExternalInputPotential(
+    strategyState: MutableStrategyState,
+    target: MutableToolStepRoleAddress,
+): MutableStrategyState {
     const mutableExternalInputPotential: MutableExternalInputPotential = {
         strategyStateEntryKind: 'externalInputPotential',
     };

package/src/utils/stepCreation.ts

@@ -1,5 +1,6 @@
 import type {
     Tool,
+    WhenInputRoleBindingSpec,
 } from '@toolproof-core/genesis';
 import type {
     MutableToolStep,
@@ -30,6 +31,7 @@ export function createToolStepFromTool(
     tool: Tool,
 ): MutableToolStep {
     return {
+        stepKey: generateIdentifier('ToolStepKey'),
         toolStepKey: generateIdentifier('ToolStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.tool,
         toolHandle: tool.handle,
@@ -37,6 +39,16 @@ export function createToolStepFromTool(
     };
 }
 
+export function createLoopSlotWhenToolStepFromTool(
+    tool: Tool,
+    whenInputRoleBindingSpec: WhenInputRoleBindingSpec,
+): MutableToolStep {
+    return {
+        ...createToolStepFromTool(tool),
+        whenInputRoleBindingSpec,
+    };
+}
+
 export function createCaseFromToolStepPair(
     what: MutableToolStep,
     when: MutableToolStep,
@@ -50,6 +62,7 @@ export function createLoopStepFromCase(
 ): MutableForStep | MutableWhileStep {
     if (stepKind === CONSTANTS.Enums.StepKind.for) {
         return {
+            stepKey: generateIdentifier('ForStepKey'),
             macroStepKey: generateIdentifier('ForStepKey'),
             stepKind: CONSTANTS.Enums.StepKind.for,
             case: stepCase,
@@ -57,6 +70,7 @@ export function createLoopStepFromCase(
     }
 
     return {
+        stepKey: generateIdentifier('WhileStepKey'),
         macroStepKey: generateIdentifier('WhileStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.while,
         case: stepCase,
@@ -69,6 +83,7 @@ export function createBranchStepFromCases(
     assertNonEmpty(cases, 'createBranchStepFromCases requires at least one case');
 
     return {
+        stepKey: generateIdentifier('BranchStepKey'),
         macroStepKey: generateIdentifier('BranchStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.branch,
         cases,
@@ -79,6 +94,7 @@ export function cloneForStep(
     forStep: MutableForStep,
 ): MutableForStep {
     return {
+        stepKey: generateIdentifier('ForStepKey'),
         macroStepKey: generateIdentifier('ForStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.for,
         case: {
@@ -98,6 +114,7 @@ export function cloneWhileStep(
     whileStep: MutableWhileStep,
 ): MutableWhileStep {
     return {
+        stepKey: generateIdentifier('WhileStepKey'),
         macroStepKey: generateIdentifier('WhileStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.while,
         case: {

package/src/utils/stepExpansion.ts

@@ -1,63 +1,56 @@
 import { CONSTANTS } from '../lookups/lookups.js';
 import type {
-    MutableBranchStep,
-    MutableForStep,
     MutableStep,
     MutableToolStep,
-    MutableToolStepKey,
-    MutableWhileStep,
 } from './mutableStrategyOverlay.js';
 
-export type StepExpansionOrder = {
+export type StepExpansionOrder = { // ATTENTION: redundant?
     branchCaseOrder?: 'when-what' | 'what-when';
     loopCaseOrder?: 'what-when' | 'when-what';
 };
 
-export function extractToolStepsFromStep<
-    TKey extends string = MutableToolStepKey,
-    TStep extends MutableStep<TKey> = MutableStep<TKey>,
->(
-    step: TStep,
+export function extractToolStepsFromStep(
+    step: MutableStep,
     order: StepExpansionOrder = {},
-): MutableToolStep<TKey>[] {
+): MutableToolStep[] {
     const {
         branchCaseOrder = 'when-what',
         loopCaseOrder = 'what-when',
     } = order;
 
     if (step.stepKind === CONSTANTS.Enums.StepKind.tool) {
-        return [step as MutableToolStep<TKey>];
+        return [step];
     }
 
     if (step.stepKind === CONSTANTS.Enums.StepKind.branch) {
-        const branch = step as MutableBranchStep<TKey>;
-        const cases = branch.cases ?? [];
+        const branchStep = step;
+        const cases = branchStep.cases ?? [];
         return cases.flatMap((stepCase) => {
             if (branchCaseOrder === 'what-when') {
                 return [stepCase.what, stepCase.when];
             }
 
             return [stepCase.when, stepCase.what];
-        }).filter(Boolean) as MutableToolStep<TKey>[];
+        });
     }
 
     if (step.stepKind === CONSTANTS.Enums.StepKind.while) {
-        const loop = step as MutableWhileStep<TKey>;
+        const whileStep = step;
         if (loopCaseOrder === 'when-what') {
-            return [loop.case.when, loop.case.what].filter(Boolean) as MutableToolStep<TKey>[];
+            return [whileStep.case.when, whileStep.case.what];
         }
 
-        return [loop.case.what, loop.case.when].filter(Boolean) as MutableToolStep<TKey>[];
+        return [whileStep.case.what, whileStep.case.when];
     }
 
     if (step.stepKind === CONSTANTS.Enums.StepKind.for) {
-        const loop = step as MutableForStep<TKey>;
+        const forStep = step;
         if (loopCaseOrder === 'when-what') {
-            return [loop.case.when, loop.case.what].filter(Boolean) as MutableToolStep<TKey>[];
+            return [forStep.case.when, forStep.case.what];
         }
 
-        return [loop.case.what, loop.case.when].filter(Boolean) as MutableToolStep<TKey>[];
+        return [forStep.case.what, forStep.case.when];
     }
 
-    return [] as MutableToolStep<TKey>[];
+    return [];
 }

package/src/utils/stepParallelization.ts

@@ -6,13 +6,10 @@ import type {
 } from './mutableStrategyOverlay.js';
 import { extractToolStepsFromStep } from './stepExpansion.js';
 
-export function getIndependentThreads<
-	TKey extends string = MutableToolStepKey,
-	TStep extends MutableStep<TKey> = MutableStep<TKey>,
->(
-	steps: TStep[],
-	strategyState: MutableStrategyState<TKey>,
-): TStep[][] {
+export function getIndependentThreads(
+	steps: MutableStep[],
+	strategyState: MutableStrategyState,
+): MutableStep[][] {
 	type OwnerIndex = number;
 
 	const getOwnerLabel = (ownerIndex: OwnerIndex) => {
@@ -20,11 +17,11 @@ export function getIndependentThreads<
 		return `steps[${ownerIndex}] stepKind=${step?.stepKind ?? 'unknown'}`;
 	};
 
-	const toolStepKeyToOwner = new Map<TKey, OwnerIndex>();
-	const toolStepByKey = new Map<TKey, MutableToolStep<TKey>>();
+	const toolStepKeyToOwner = new Map<MutableToolStepKey, OwnerIndex>();
+	const toolStepByKey = new Map<MutableToolStepKey, MutableToolStep>();
 
 	const addToolStep = (
-		toolStep: MutableToolStep<TKey> | undefined,
+		toolStep: MutableToolStep | undefined,
 		ownerIndex: OwnerIndex,
 	) => {
 		if (!toolStep) return;
@@ -41,7 +38,7 @@ export function getIndependentThreads<
 	};
 
 	steps.forEach((step, ownerIndex) => {
-		for (const toolStep of extractToolStepsFromStep<TKey, TStep>(step, { branchCaseOrder: 'what-when' })) {
+		for (const toolStep of extractToolStepsFromStep(step, { branchCaseOrder: 'what-when' })) {
 			addToolStep(toolStep, ownerIndex);
 		}
 	});
@@ -76,7 +73,7 @@ export function getIndependentThreads<
 				);
 			}
 
-			const producerOwner = toolStepKeyToOwner.get(producerToolStepKey as TKey);
+			const producerOwner = toolStepKeyToOwner.get(producerToolStepKey);
 			if (producerOwner === undefined) {
 				throw new Error(
 					`Unresolvable internalInputPotential in toolStep '${toolStepKey}' (${getOwnerLabel(ownerIndex)}): source toolStepKey '${producerToolStepKey}' not found in strategy steps`

package/src/utils/strategyAssembly.ts

@@ -4,8 +4,8 @@ import { toExecutionMutableStrategy } from './strategyThreading.js';
 import { mutableStrategyToStrategy } from './strategyCanonicalization.js';
 
 
-export function composeStrategyForExecution<TKey extends string>(
-    mutableStrategy: MutableStrategy<TKey>,
+export function composeStrategyForExecution(
+    mutableStrategy: MutableStrategy,
 ): Strategy {
     const executionStrategy =
         toExecutionMutableStrategy(mutableStrategy);

package/src/utils/strategyCanonicalization.ts

@@ -23,6 +23,7 @@ import type {
     MutableStep,
     MutableStrategyStateEntryByRoleName,
     MutableStrategyStateEntry,
+    MutableToolStep,
     MutableToolStepKey,
     MutableWhileStep,
 } from './mutableStrategyOverlay.js';
@@ -30,8 +31,8 @@ import { generateIdentifier } from './identifierGeneration.js';
 
 function stripMutableCase(stepCase: MutableCase): Case {
     const { when, what, ...rest } = stepCase;
-    const { toolStepKey: _whenToolStepKey, ...canonicalWhen } = when;
-    const { toolStepKey: _whatToolStepKey, ...canonicalWhat } = what;
+    const { stepKey: _whenStepKey, toolStepKey: _whenToolStepKey, ...canonicalWhen } = when;
+    const { stepKey: _whatStepKey, toolStepKey: _whatToolStepKey, ...canonicalWhat } = what;
 
     return {
         ...rest,
@@ -98,11 +99,11 @@ function toCanonicalStrategyStateEntry(
 function toCanonicalStep(step: MutableStep): Step {
     switch (step.stepKind) {
         case CONSTANTS.Enums.StepKind.tool: {
-            const { toolStepKey: _toolStepKey, ...canonicalToolStep } = step;
+            const { stepKey: _stepKey, toolStepKey: _toolStepKey, ...canonicalToolStep } = step;
             return canonicalToolStep;
         }
         case CONSTANTS.Enums.StepKind.branch: {
-            const { macroStepKey: _macroStepKey, cases, ...rest } = step;
+            const { stepKey: _stepKey, macroStepKey: _macroStepKey, cases, ...rest } = step;
             return {
                 ...rest,
                 cases: cases.map(stripMutableCase) as [Case, ...Case[]],
@@ -110,7 +111,7 @@ function toCanonicalStep(step: MutableStep): Step {
         }
         case CONSTANTS.Enums.StepKind.while:
         case CONSTANTS.Enums.StepKind.for: {
-            const { macroStepKey: _macroStepKey, case: stepCase, ...rest } = step;
+            const { stepKey: _stepKey, macroStepKey: _macroStepKey, case: stepCase, ...rest } = step;
             return {
                 ...rest,
                 case: stripMutableCase(stepCase),
@@ -137,16 +138,19 @@ function toMutableStrategyStateEntry(
     return {
         strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
+            stepKey: sourceToolStepKey,
             toolStepKey: sourceToolStepKey,
             roleName: entry.toolStepRoleAddress.roleName,
         },
     } satisfies MutableInternalInputPotential;
 }
 
-function toMutableToolStep(step: ToolStep) {
+function toMutableToolStep(step: ToolStep): MutableToolStep {
+    const key = generateIdentifier('ToolStepKey');
     return {
         ...step,
-        toolStepKey: generateIdentifier('ToolStepKey'),
+        stepKey: key,
+        toolStepKey: key,
     };
 }
 
@@ -163,9 +167,11 @@ function toMutableCase(stepCase: Case): MutableCase {
 function toMutableBranchStep(step: BranchStep): MutableBranchStep {
     const { cases, ...rest } = step;
 
+    const key = generateIdentifier('BranchStepKey');
     return {
         ...rest,
-        macroStepKey: generateIdentifier('BranchStepKey'),
+        stepKey: key,
+        macroStepKey: key,
         cases: cases.map(toMutableCase) as [MutableCase, ...MutableCase[]],
     };
 }
@@ -173,9 +179,11 @@ function toMutableBranchStep(step: BranchStep): MutableBranchStep {
 function toMutableWhileStep(step: WhileStep): MutableWhileStep {
     const { case: stepCase, ...rest } = step;
 
+    const key = generateIdentifier('WhileStepKey');
     return {
         ...rest,
-        macroStepKey: generateIdentifier('WhileStepKey'),
+        stepKey: key,
+        macroStepKey: key,
         case: toMutableCase(stepCase),
     };
 }
@@ -183,9 +191,11 @@ function toMutableWhileStep(step: WhileStep): MutableWhileStep {
 function toMutableForStep(step: ForStep): MutableForStep {
     const { case: stepCase, ...rest } = step;
 
+    const key = generateIdentifier('ForStepKey');
     return {
         ...rest,
-        macroStepKey: generateIdentifier('ForStepKey'),
+        stepKey: key,
+        macroStepKey: key,
         case: toMutableCase(stepCase),
     };
 }
@@ -266,7 +276,7 @@ export function mutableStrategyToStrategy(mutableStrategy: MutableStrategy): Str
             continue;
         }
 
-        const toolStepPath = executionPathByKey.get(toolStepKey);
+        const toolStepPath = executionPathByKey.get(toolStepKey as MutableToolStepKey);
         if (!toolStepPath) {
             throw new Error(`Cannot project strategy state: no execution path found for toolStepKey '${toolStepKey}'.`);
         }

package/src/utils/strategyStateResolution.ts

@@ -1,32 +1,29 @@
 import type {
 	MutableMaterializedResource,
 	MutableExternalInputPotential,
-	MutableInternalInputPotential,
 	MutableStrategyState,
-	MutableStrategyStateEntry,
-	MutableToolStepKey,
 	MutableToolStepRoleAddress,
 } from './mutableStrategyOverlay.js';
 import { getStrategyStateEntry } from './mutableStrategyOverlay.js';
 
-export type ResolveResult<TKey extends string = MutableToolStepKey> =
-	| { status: 'materializedResource'; entry: MutableMaterializedResource; path: MutableToolStepRoleAddress<TKey>[] }
-	| { status: 'externalInputPotential'; entry: MutableExternalInputPotential; path: MutableToolStepRoleAddress<TKey>[] }
+export type ResolveResult =
+	| { status: 'materializedResource'; entry: MutableMaterializedResource; path: MutableToolStepRoleAddress[] }
+	| { status: 'externalInputPotential'; entry: MutableExternalInputPotential; path: MutableToolStepRoleAddress[] }
 	| {
 		status: 'unresolved';
 		reason: 'not-found' | 'cycle' | 'depth-exceeded';
-		path: MutableToolStepRoleAddress<TKey>[];
+		path: MutableToolStepRoleAddress[];
 	};
 
-export function resolveStrategyStateChain<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
-	strategyState: TStrategyState,
-	start: MutableToolStepRoleAddress<TKey>,
+export function resolveStrategyStateChain(
+	strategyState: MutableStrategyState,
+	start: MutableToolStepRoleAddress,
 	opts?: { maxDepth?: number },
-): ResolveResult<TKey> {
+): ResolveResult {
 	const maxDepth = opts?.maxDepth ?? 50;
 	const visited = new Set<string>();
-	const path: MutableToolStepRoleAddress<TKey>[] = [];
-	let current: MutableToolStepRoleAddress<TKey> = start;
+	const path: MutableToolStepRoleAddress[] = [];
+	let current: MutableToolStepRoleAddress = start;
 
 	for (let depth = 0; depth <= maxDepth; depth++) {
 		path.push(current);
@@ -37,7 +34,7 @@ export function resolveStrategyStateChain<TKey extends string, TStrategyState ex
 		}
 		visited.add(visitKey);
 
-		const entry = getStrategyStateEntry(strategyState, current) as MutableStrategyStateEntry<TKey> | undefined;
+		const entry = getStrategyStateEntry(strategyState, current);
 		if (!entry) {
 			return { status: 'unresolved', reason: 'not-found', path };
 		}
@@ -50,7 +47,7 @@ export function resolveStrategyStateChain<TKey extends string, TStrategyState ex
 			return { status: 'externalInputPotential', entry, path };
 		}
 
-		current = (entry as MutableInternalInputPotential<TKey>).toolStepRoleAddress;
+		current = entry.toolStepRoleAddress;
 	}
 
 	return { status: 'unresolved', reason: 'depth-exceeded', path };