@toolproof-core/lib 1.0.47 → 1.0.49

package/dist/utils/strategyStateResolution.d.ts

@@ -1,17 +1,17 @@
-import type { MutableMaterializedResource, MutableExternalInputPotential, MutableStrategyState, MutableToolStepKey, MutableToolStepRoleAddress } from './mutableStrategyOverlay.js';
-export type ResolveResult<TKey extends string = MutableToolStepKey> = {
+import type { MutableMaterializedResource, MutableExternalInputPotential, MutableStrategyState, MutableToolStepRoleAddress } from './mutableStrategyOverlay.js';
+export type ResolveResult = {
     status: 'materializedResource';
     entry: MutableMaterializedResource;
-    path: MutableToolStepRoleAddress<TKey>[];
+    path: MutableToolStepRoleAddress[];
 } | {
     status: 'externalInputPotential';
     entry: MutableExternalInputPotential;
-    path: MutableToolStepRoleAddress<TKey>[];
+    path: MutableToolStepRoleAddress[];
 } | {
     status: 'unresolved';
     reason: 'not-found' | 'cycle' | 'depth-exceeded';
-    path: MutableToolStepRoleAddress<TKey>[];
+    path: MutableToolStepRoleAddress[];
 };
-export declare function resolveStrategyStateChain<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, start: MutableToolStepRoleAddress<TKey>, opts?: {
+export declare function resolveStrategyStateChain(strategyState: MutableStrategyState, start: MutableToolStepRoleAddress, opts?: {
     maxDepth?: number;
-}): ResolveResult<TKey>;
+}): ResolveResult;

package/dist/utils/strategyStateResolution.js

@@ -6,7 +6,7 @@ export function resolveStrategyStateChain(strategyState, start, opts) {
     let current = start;
     for (let depth = 0; depth <= maxDepth; depth++) {
         path.push(current);
-        const visitKey = `${current.toolStepKey}::${current.roleName}`;
+        const visitKey = `${current.stepKey}::${current.roleName}`;
         if (visited.has(visitKey)) {
             return { status: 'unresolved', reason: 'cycle', path };
         }

package/dist/utils/strategyThreading.d.ts

@@ -1,2 +1,2 @@
-import type { MutableStrategy, MutableStep, MutableStrategyState, MutableToolStepKey } from './mutableStrategyOverlay.js';
-export declare function toExecutionMutableStrategy<TKey extends string = MutableToolStepKey, TStep extends MutableStep<TKey> = MutableStep<TKey>, TState extends MutableStrategyState<TKey> = MutableStrategyState<TKey>>(mutableStrategy: MutableStrategy<TKey, TStep, TState>): MutableStrategy<TKey, TStep, TState>;
+import type { MutableStrategy } from './mutableStrategyOverlay.js';
+export declare function toExecutionMutableStrategy(mutableStrategy: MutableStrategy): MutableStrategy;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-core/lib",
-  "version": "1.0.47",
+  "version": "1.0.49",
   "description": "",
   "type": "module",
   "keywords": [],
@@ -80,7 +80,7 @@
     "@types/node": "^22.0.0"
   },
   "dependencies": {
-    "@toolproof-core/genesis": "^1.0.63",
+    "@toolproof-core/genesis": "^1.0.65",
     "firebase-admin": "^13.7.0"
   },
   "scripts": {

package/src/utils/mutableStrategyOverlay.ts

@@ -16,97 +16,85 @@ 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;
     };
 
-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;
 };
 
-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,48 +104,45 @@ export function setAuthoringSteps< // ATTENTION
     };
 }
 
-export function getStrategyStateEntryByRoleName<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
-    strategyState: TStrategyState,
-    toolStepKey: TKey,
-): MutableStrategyStateEntryByRoleName<TKey> | undefined {
-    return strategyState[toolStepKey];
+export function getStrategyStateEntryByRoleName(
+    strategyState: MutableStrategyState,
+    stepKey: MutableToolStepKey,
+): MutableStrategyStateEntryByRoleName | undefined {
+    return strategyState[stepKey];
 }
 
-export function getStrategyStateEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
-    strategyState: TStrategyState,
-    toolStepRoleAddress: MutableToolStepRoleAddress<TKey>,
-): MutableStrategyStateEntry<TKey> | undefined {
-    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey);
+export function getStrategyStateEntry(
+    strategyState: MutableStrategyState,
+    toolStepRoleAddress: MutableToolStepRoleAddress,
+): MutableStrategyStateEntry | undefined {
+    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.stepKey);
     return inputEntryByRoleName?.[toolStepRoleAddress.roleName];
 }
 
-export function setStrategyStateEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
-    strategyState: TStrategyState,
-    toolStepRoleAddress: MutableToolStepRoleAddress<TKey>,
-    entry: MutableStrategyStateEntry<TKey>,
-): TStrategyState {
-    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey) ?? {};
+export function setStrategyStateEntry(
+    strategyState: MutableStrategyState,
+    toolStepRoleAddress: MutableToolStepRoleAddress,
+    entry: MutableStrategyStateEntry,
+): MutableStrategyState {
+    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.stepKey) ?? {};
 
     return {
         ...strategyState,
-        [toolStepRoleAddress.toolStepKey]: {
+        [toolStepRoleAddress.stepKey]: {
             ...inputEntryByRoleName,
             [toolStepRoleAddress.roleName]: entry,
         },
     };
 }
 
-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,
-            toolStepRoleAddress.toolStepKey,
+            toolStepRoleAddress.stepKey,
         );
 
     if (!inputEntryByRoleName || !(toolStepRoleAddress.roleName in inputEntryByRoleName)) {
@@ -169,21 +154,21 @@ export function clearInputBinding<
 
     if (Object.keys(nextInputEntryByRoleName).length === 0) {
         const nextStrategyState = { ...strategyState };
-        delete nextStrategyState[toolStepRoleAddress.toolStepKey];
-        return nextStrategyState as TStrategyState;
+        delete nextStrategyState[toolStepRoleAddress.stepKey];
+        return nextStrategyState;
     }
 
     return {
         ...strategyState,
-        [toolStepRoleAddress.toolStepKey]: nextInputEntryByRoleName,
+        [toolStepRoleAddress.stepKey]: nextInputEntryByRoleName,
     };
 }
 
-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,24 +185,24 @@ 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);
+    const sourceToolStep = context.toolStepByKey.get(sourceAddress.stepKey);
     if (!sourceToolStep) {
-        throw new Error(`Source tool step not found for '${sourceAddress.toolStepKey}'.`);
+        throw new Error(`Source tool step not found for '${sourceAddress.stepKey}'.`);
     }
 
-    const targetToolStep = context.toolStepByKey.get(targetAddress.toolStepKey);
+    const targetToolStep = context.toolStepByKey.get(targetAddress.stepKey);
     if (!targetToolStep) {
-        throw new Error(`Target tool step not found for '${targetAddress.toolStepKey}'.`);
+        throw new Error(`Target tool step not found for '${targetAddress.stepKey}'.`);
     }
 
     const sourceTool = context.toolMap.get(sourceToolStep.toolHandle);
@@ -232,13 +217,13 @@ export function bindInternalInputPotential<TKey extends string, TStrategyState e
 
     const targetInputRoleValue = getInputRoleValue(targetTool, targetAddress.roleName);
     if (!targetInputRoleValue) {
-        throw new Error(`Target input role not found for (${targetAddress.toolStepKey}, ${targetAddress.roleName}).`);
+        throw new Error(`Target input role not found for (${targetAddress.stepKey}, ${targetAddress.roleName}).`);
     }
 
     const sourceOutputRoleValue = getOutputRoleValue(sourceTool, sourceAddress.roleName);
     const sourceInputRoleValue = getInputRoleValue(sourceTool, sourceAddress.roleName);
 
-    const sourceInputEntryByRoleName = strategyState[sourceAddress.toolStepKey];
+    const sourceInputEntryByRoleName = strategyState[sourceAddress.stepKey];
     const sourceInputEntry = sourceInputEntryByRoleName?.[sourceAddress.roleName];
 
     const sourceRoleType = sourceOutputRoleValue
@@ -251,33 +236,33 @@ export function bindInternalInputPotential<TKey extends string, TStrategyState e
 
     if (!sourceOutputRoleValue && sourceInputRoleValue) {
         if (!sourceInputEntry) {
-            throw new Error(`Source input role is not bound for (${sourceAddress.toolStepKey}, ${sourceAddress.roleName}).`); // ATTENTION: not an ontological invariant, but it might help catch some mistakes early on.
+            throw new Error(`Source input role is not bound for (${sourceAddress.stepKey}, ${sourceAddress.roleName}).`); // ATTENTION: not an ontological invariant, but it might help catch some mistakes early on.
         }
     }
 
     if (!sourceOutputRoleValue && !sourceInputRoleValue) {
-        throw new Error(`Source role not found for (${sourceAddress.toolStepKey}, ${sourceAddress.roleName}).`);
+        throw new Error(`Source role not found for (${sourceAddress.stepKey}, ${sourceAddress.roleName}).`);
     }
 
     if (!sourceRoleType || !targetRoleType || sourceRoleType !== targetRoleType) {
         throw new Error(
-            `Reference type mismatch between source (${sourceAddress.toolStepKey}, ${sourceAddress.roleName}) and target (${targetAddress.toolStepKey}, ${targetAddress.roleName}).`
+            `Reference type mismatch between source (${sourceAddress.stepKey}, ${sourceAddress.roleName}) and target (${targetAddress.stepKey}, ${targetAddress.roleName}).`
         );
     }
 
     return setStrategyStateEntry(strategyState, targetAddress, {
         strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
-            toolStepKey: sourceAddress.toolStepKey,
+            stepKey: sourceAddress.stepKey,
             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

@@ -31,7 +31,7 @@ export function createToolStepFromTool(
     tool: Tool,
 ): MutableToolStep {
     return {
-        toolStepKey: generateIdentifier('ToolStepKey'),
+        stepKey: generateIdentifier('ToolStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.tool,
         toolHandle: tool.handle,
         roleBindingSpec: getRoleBindingSpec(tool),
@@ -61,6 +61,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,
@@ -68,6 +69,7 @@ export function createLoopStepFromCase(
     }
 
     return {
+        stepKey: generateIdentifier('WhileStepKey'),
         macroStepKey: generateIdentifier('WhileStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.while,
         case: stepCase,
@@ -80,6 +82,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,
@@ -90,16 +93,17 @@ export function cloneForStep(
     forStep: MutableForStep,
 ): MutableForStep {
     return {
+        stepKey: generateIdentifier('ForStepKey'),
         macroStepKey: generateIdentifier('ForStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.for,
         case: {
             what: {
                 ...forStep.case.what,
-                toolStepKey: generateIdentifier('ToolStepKey'),
+                stepKey: generateIdentifier('ToolStepKey'),
             },
             when: {
                 ...forStep.case.when,
-                toolStepKey: generateIdentifier('ToolStepKey'),
+                stepKey: generateIdentifier('ToolStepKey'),
             },
         },
     };
@@ -109,16 +113,17 @@ export function cloneWhileStep(
     whileStep: MutableWhileStep,
 ): MutableWhileStep {
     return {
+        stepKey: generateIdentifier('WhileStepKey'),
         macroStepKey: generateIdentifier('WhileStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.while,
         case: {
             what: {
                 ...whileStep.case.what,
-                toolStepKey: generateIdentifier('ToolStepKey'),
+                stepKey: generateIdentifier('ToolStepKey'),
             },
             when: {
                 ...whileStep.case.when,
-                toolStepKey: generateIdentifier('ToolStepKey'),
+                stepKey: generateIdentifier('ToolStepKey'),
             },
         },
     };

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,28 +17,28 @@ export function getIndependentThreads<
 		return `steps[${ownerIndex}] stepKind=${step?.stepKind ?? 'unknown'}`;
 	};
 
-	const toolStepKeyToOwner = new Map<TKey, OwnerIndex>();
-	const toolStepByKey = new Map<TKey, MutableToolStep<TKey>>();
+	const stepKeyToOwner = new Map<MutableToolStepKey, OwnerIndex>();
+	const toolStepByKey = new Map<MutableToolStepKey, MutableToolStep>();
 
 	const addToolStep = (
-		toolStep: MutableToolStep<TKey> | undefined,
+		toolStep: MutableToolStep | undefined,
 		ownerIndex: OwnerIndex,
 	) => {
 		if (!toolStep) return;
 
-		const existingOwner = toolStepKeyToOwner.get(toolStep.toolStepKey);
+		const existingOwner = stepKeyToOwner.get(toolStep.stepKey);
 		if (existingOwner !== undefined) {
 			throw new Error(
-				`Duplicate toolStepKey '${toolStep.toolStepKey}' found in ${getOwnerLabel(ownerIndex)} and ${getOwnerLabel(existingOwner)}`
+				`Duplicate stepKey '${toolStep.stepKey}' found in ${getOwnerLabel(ownerIndex)} and ${getOwnerLabel(existingOwner)}`
 			);
 		}
 
-		toolStepKeyToOwner.set(toolStep.toolStepKey, ownerIndex);
-		toolStepByKey.set(toolStep.toolStepKey, toolStep);
+		stepKeyToOwner.set(toolStep.stepKey, ownerIndex);
+		toolStepByKey.set(toolStep.stepKey, toolStep);
 	};
 
 	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);
 		}
 	});
@@ -58,28 +55,28 @@ export function getIndependentThreads<
 		ensureOwner(index);
 	}
 
-	for (const [toolStepKey, ownerIndex] of toolStepKeyToOwner) {
+	for (const [stepKey, ownerIndex] of stepKeyToOwner) {
 		ensureOwner(ownerIndex);
 
-		const toolStep = toolStepByKey.get(toolStepKey);
+		const toolStep = toolStepByKey.get(stepKey);
 		const inputBindings = toolStep?.roleBindingSpec?.inputBindings ?? [];
-		const bucket = strategyState[toolStepKey];
+		const bucket = strategyState[stepKey];
 
 		for (const inputRoleId of inputBindings) {
 			const entry = bucket?.[inputRoleId];
 			if (!entry || entry.strategyStateEntryKind !== 'internalInputPotential') continue;
 
-			const producerToolStepKey = entry.toolStepRoleAddress?.toolStepKey;
-			if (typeof producerToolStepKey !== 'string') {
+			const producerStepKey = entry.toolStepRoleAddress?.stepKey;
+			if (typeof producerStepKey !== 'string') {
 				throw new Error(
-					`Unresolvable internalInputPotential in toolStep '${toolStepKey}' (${getOwnerLabel(ownerIndex)}): missing toolStepRoleAddress.toolStepKey for role '${inputRoleId}'`
+					`Unresolvable internalInputPotential in toolStep '${stepKey}' (${getOwnerLabel(ownerIndex)}): missing toolStepRoleAddress.stepKey for role '${inputRoleId}'`
 				);
 			}
 
-			const producerOwner = toolStepKeyToOwner.get(producerToolStepKey as TKey);
+			const producerOwner = stepKeyToOwner.get(producerStepKey);
 			if (producerOwner === undefined) {
 				throw new Error(
-					`Unresolvable internalInputPotential in toolStep '${toolStepKey}' (${getOwnerLabel(ownerIndex)}): source toolStepKey '${producerToolStepKey}' not found in strategy steps`
+					`Unresolvable internalInputPotential in toolStep '${stepKey}' (${getOwnerLabel(ownerIndex)}): source stepKey '${producerStepKey}' 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);