@toolproof-core/lib 1.0.48 → 1.0.50

package/dist/utils/mutableStrategyOverlay.d.ts

@@ -4,12 +4,10 @@ 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 MutableStepKey = MutableToolStepKey | MutableBranchStepKey | MutableLoopStepKey;
 export type MutableMaterializedResource = MaterializedResource;
 export type MutableToolStepRoleAddress = Omit<ToolStepRoleAddress, 'toolStepPath'> & {
     stepKey: MutableToolStepKey;
-    toolStepKey: MutableToolStepKey;
 };
 export type MutableInternalInputPotential = Omit<InternalInputPotential, 'toolStepRoleAddress'> & {
     toolStepRoleAddress: MutableToolStepRoleAddress;
@@ -20,7 +18,6 @@ export type MutableStrategyStateEntryByRoleName = Partial<Record<RoleName, Mutab
 export type MutableStrategyState = Partial<Record<MutableToolStepKey, MutableStrategyStateEntryByRoleName>>;
 export type MutableToolStep = ToolStep & {
     stepKey: MutableToolStepKey;
-    toolStepKey: MutableToolStepKey;
 };
 export type MutableCase = Omit<Case, 'when' | 'what'> & {
     when: MutableToolStep;
@@ -28,17 +25,14 @@ export type MutableCase = Omit<Case, 'when' | 'what'> & {
 };
 export type MutableBranchStep = Omit<BranchStep, 'cases'> & {
     stepKey: MutableBranchStepKey;
-    macroStepKey: MutableBranchStepKey;
     cases: [MutableCase, ...MutableCase[]];
 };
 export type MutableWhileStep = Omit<WhileStep, 'case'> & {
     stepKey: MutableWhileStepKey;
-    macroStepKey: MutableWhileStepKey;
     case: MutableCase;
 };
 export type MutableForStep = Omit<ForStep, 'case'> & {
     stepKey: MutableForStepKey;
-    macroStepKey: MutableForStepKey;
     case: MutableCase;
 };
 export type MutableStep = MutableToolStep | MutableBranchStep | MutableWhileStep | MutableForStep;
@@ -48,7 +42,7 @@ export type MutableStrategy = Omit<Strategy, 'stepsByThreadIndex' | 'strategySta
 };
 export declare function getAuthoringSteps(strategy: MutableStrategy): MutableStep[];
 export declare function setAuthoringSteps(strategy: MutableStrategy, steps: MutableStep[]): MutableStrategy;
-export declare function getStrategyStateEntryByRoleName(strategyState: MutableStrategyState, toolStepKey: MutableToolStepKey): MutableStrategyStateEntryByRoleName | undefined;
+export declare function getStrategyStateEntryByRoleName(strategyState: MutableStrategyState, stepKey: MutableToolStepKey): MutableStrategyStateEntryByRoleName | undefined;
 export declare function getStrategyStateEntry(strategyState: MutableStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress): MutableStrategyStateEntry | undefined;
 export declare function setStrategyStateEntry(strategyState: MutableStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress, entry: MutableStrategyStateEntry): MutableStrategyState;
 export declare function clearInputBinding(strategyState: MutableStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress): MutableStrategyState;

package/dist/utils/mutableStrategyOverlay.js

@@ -10,25 +10,25 @@ export function setAuthoringSteps(strategy, steps) {
         stepsByThreadIndex: nextStepsByThreadIndex,
     };
 }
-export function getStrategyStateEntryByRoleName(strategyState, toolStepKey) {
-    return strategyState[toolStepKey];
+export function getStrategyStateEntryByRoleName(strategyState, stepKey) {
+    return strategyState[stepKey];
 }
 export function getStrategyStateEntry(strategyState, toolStepRoleAddress) {
-    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey);
+    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.stepKey);
     return inputEntryByRoleName?.[toolStepRoleAddress.roleName];
 }
 export function setStrategyStateEntry(strategyState, toolStepRoleAddress, entry) {
-    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey) ?? {};
+    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.stepKey) ?? {};
     return {
         ...strategyState,
-        [toolStepRoleAddress.toolStepKey]: {
+        [toolStepRoleAddress.stepKey]: {
             ...inputEntryByRoleName,
             [toolStepRoleAddress.roleName]: entry,
         },
     };
 }
 export function clearInputBinding(strategyState, toolStepRoleAddress) {
-    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey);
+    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.stepKey);
     if (!inputEntryByRoleName || !(toolStepRoleAddress.roleName in inputEntryByRoleName)) {
         return strategyState;
     }
@@ -36,12 +36,12 @@ export function clearInputBinding(strategyState, toolStepRoleAddress) {
     delete nextInputEntryByRoleName[toolStepRoleAddress.roleName];
     if (Object.keys(nextInputEntryByRoleName).length === 0) {
         const nextStrategyState = { ...strategyState };
-        delete nextStrategyState[toolStepRoleAddress.toolStepKey];
+        delete nextStrategyState[toolStepRoleAddress.stepKey];
         return nextStrategyState;
     }
     return {
         ...strategyState,
-        [toolStepRoleAddress.toolStepKey]: nextInputEntryByRoleName,
+        [toolStepRoleAddress.stepKey]: nextInputEntryByRoleName,
     };
 }
 export function bindMaterializedResource(strategyState, target, resource) {
@@ -58,13 +58,13 @@ function getOutputRoleValue(tool, roleName) {
     return tool.roleSpec.outputRoleValueByName[roleName];
 }
 export function bindInternalInputPotential(strategyState, targetAddress, sourceAddress, context) {
-    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);
     if (!sourceTool) {
@@ -76,11 +76,11 @@ export function bindInternalInputPotential(strategyState, targetAddress, sourceA
     }
     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
         ? extractResourceTypeHandleFromRoleValue(sourceOutputRoleValue)
@@ -90,20 +90,19 @@ export function bindInternalInputPotential(strategyState, targetAddress, sourceA
     const targetRoleType = extractResourceTypeHandleFromRoleValue(targetInputRoleValue);
     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}).`);
+        throw new Error(`Reference type mismatch between source (${sourceAddress.stepKey}, ${sourceAddress.roleName}) and target (${targetAddress.stepKey}, ${targetAddress.roleName}).`);
     }
     return setStrategyStateEntry(strategyState, targetAddress, {
         strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
             stepKey: sourceAddress.stepKey,
-            toolStepKey: sourceAddress.toolStepKey,
             roleName: sourceAddress.roleName,
         },
     });

package/dist/utils/stepCreation.js

@@ -15,7 +15,6 @@ function getRoleBindingSpec(tool) {
 export function createToolStepFromTool(tool) {
     return {
         stepKey: generateIdentifier('ToolStepKey'),
-        toolStepKey: generateIdentifier('ToolStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.tool,
         toolHandle: tool.handle,
         roleBindingSpec: getRoleBindingSpec(tool),
@@ -34,14 +33,12 @@ export function createLoopStepFromCase(stepCase, stepKind) {
     if (stepKind === CONSTANTS.Enums.StepKind.for) {
         return {
             stepKey: generateIdentifier('ForStepKey'),
-            macroStepKey: generateIdentifier('ForStepKey'),
             stepKind: CONSTANTS.Enums.StepKind.for,
             case: stepCase,
         };
     }
     return {
         stepKey: generateIdentifier('WhileStepKey'),
-        macroStepKey: generateIdentifier('WhileStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.while,
         case: stepCase,
     };
@@ -50,7 +47,6 @@ export function createBranchStepFromCases(cases) {
     assertNonEmpty(cases, 'createBranchStepFromCases requires at least one case');
     return {
         stepKey: generateIdentifier('BranchStepKey'),
-        macroStepKey: generateIdentifier('BranchStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.branch,
         cases,
     };
@@ -58,16 +54,15 @@ export function createBranchStepFromCases(cases) {
 export function cloneForStep(forStep) {
     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'),
             },
         },
     };
@@ -75,16 +70,15 @@ export function cloneForStep(forStep) {
 export function cloneWhileStep(whileStep) {
     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/dist/utils/stepParallelization.js

@@ -4,17 +4,17 @@ export function getIndependentThreads(steps, strategyState) {
         const step = steps[ownerIndex];
         return `steps[${ownerIndex}] stepKind=${step?.stepKind ?? 'unknown'}`;
     };
-    const toolStepKeyToOwner = new Map();
+    const stepKeyToOwner = new Map();
     const toolStepByKey = new Map();
     const addToolStep = (toolStep, 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)}`);
+            throw new Error(`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(step, { branchCaseOrder: 'what-when' })) {
@@ -32,22 +32,22 @@ export function getIndependentThreads(steps, strategyState) {
     for (let index = 0; index < steps.length; index++) {
         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') {
-                throw new Error(`Unresolvable internalInputPotential in toolStep '${toolStepKey}' (${getOwnerLabel(ownerIndex)}): missing toolStepRoleAddress.toolStepKey for role '${inputRoleId}'`);
+            const producerStepKey = entry.toolStepRoleAddress?.stepKey;
+            if (typeof producerStepKey !== 'string') {
+                throw new Error(`Unresolvable internalInputPotential in toolStep '${stepKey}' (${getOwnerLabel(ownerIndex)}): missing toolStepRoleAddress.stepKey for role '${inputRoleId}'`);
             }
-            const producerOwner = toolStepKeyToOwner.get(producerToolStepKey);
+            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`);
+                throw new Error(`Unresolvable internalInputPotential in toolStep '${stepKey}' (${getOwnerLabel(ownerIndex)}): source stepKey '${producerStepKey}' not found in strategy steps`);
             }
             ensureOwner(producerOwner);
             ownerAdj.get(ownerIndex)?.add(producerOwner);

package/dist/utils/strategyCanonicalization.d.ts

@@ -2,5 +2,5 @@ import type { Strategy, ToolStepPath } from '@toolproof-core/genesis';
 import type { MutableStrategy, MutableStrategyStateEntryByRoleName, MutableToolStepKey } from './mutableStrategyOverlay.js';
 export declare function strategyToMutableStrategy(strategy: Strategy): MutableStrategy;
 export declare function mutableStrategyToStrategy(mutableStrategy: MutableStrategy): Strategy;
-export declare function mutableToolStepKeyToToolStepPath(mutableStrategy: MutableStrategy, toolStepKey: MutableToolStepKey): ToolStepPath;
-export declare function projectMutableStrategyStateEntriesByToolStepKeyToCanonicalDelta(mutableStrategy: MutableStrategy, toolStepKey: MutableToolStepKey, entries: MutableStrategyStateEntryByRoleName): Strategy['strategyState'];
+export declare function mutableStepKeyToToolStepPath(mutableStrategy: MutableStrategy, stepKey: MutableToolStepKey): ToolStepPath;
+export declare function projectMutableStrategyStateEntriesByStepKeyToCanonicalDelta(mutableStrategy: MutableStrategy, stepKey: MutableToolStepKey, entries: MutableStrategyStateEntryByRoleName): Strategy['strategyState'];

package/dist/utils/strategyCanonicalization.js

@@ -2,8 +2,8 @@ import { CONSTANTS } from '../lookups/lookups.js';
 import { generateIdentifier } from './identifierGeneration.js';
 function stripMutableCase(stepCase) {
     const { when, what, ...rest } = stepCase;
-    const { stepKey: _whenStepKey, toolStepKey: _whenToolStepKey, ...canonicalWhen } = when;
-    const { stepKey: _whatStepKey, toolStepKey: _whatToolStepKey, ...canonicalWhat } = what;
+    const { stepKey: _whenStepKey, ...canonicalWhen } = when;
+    const { stepKey: _whatStepKey, ...canonicalWhat } = what;
     return {
         ...rest,
         when: canonicalWhen,
@@ -15,18 +15,18 @@ function buildExecutionPathMap(strategy) {
     const registerStep = (step, pathPrefix) => {
         switch (step.stepKind) {
             case CONSTANTS.Enums.StepKind.tool:
-                executionPathByKey.set(step.toolStepKey, `${pathPrefix}/self`);
+                executionPathByKey.set(step.stepKey, `${pathPrefix}/self`);
                 return;
             case CONSTANTS.Enums.StepKind.branch:
                 step.cases.forEach((stepCase, caseIndex) => {
-                    executionPathByKey.set(stepCase.when.toolStepKey, `${pathPrefix}/cases/${caseIndex}/when`);
-                    executionPathByKey.set(stepCase.what.toolStepKey, `${pathPrefix}/cases/${caseIndex}/what`);
+                    executionPathByKey.set(stepCase.when.stepKey, `${pathPrefix}/cases/${caseIndex}/when`);
+                    executionPathByKey.set(stepCase.what.stepKey, `${pathPrefix}/cases/${caseIndex}/what`);
                 });
                 return;
             case CONSTANTS.Enums.StepKind.while:
             case CONSTANTS.Enums.StepKind.for:
-                executionPathByKey.set(step.case.when.toolStepKey, `${pathPrefix}/case/when`);
-                executionPathByKey.set(step.case.what.toolStepKey, `${pathPrefix}/case/what`);
+                executionPathByKey.set(step.case.when.stepKey, `${pathPrefix}/case/when`);
+                executionPathByKey.set(step.case.what.stepKey, `${pathPrefix}/case/what`);
                 return;
             default:
                 throw new Error('Unsupported step kind while projecting strategy.');
@@ -43,9 +43,9 @@ function toCanonicalStrategyStateEntry(entry, executionPathByKey) {
     if (entry.strategyStateEntryKind !== 'internalInputPotential') {
         return entry;
     }
-    const sourceToolStepPath = executionPathByKey.get(entry.toolStepRoleAddress.toolStepKey);
+    const sourceToolStepPath = executionPathByKey.get(entry.toolStepRoleAddress.stepKey);
     if (!sourceToolStepPath) {
-        throw new Error(`Cannot project strategy state: no execution path found for toolStepKey '${entry.toolStepRoleAddress.toolStepKey}'.`);
+        throw new Error(`Cannot project strategy state: no execution path found for stepKey '${entry.toolStepRoleAddress.stepKey}'.`);
     }
     return {
         strategyStateEntryKind: 'internalInputPotential',
@@ -58,11 +58,11 @@ function toCanonicalStrategyStateEntry(entry, executionPathByKey) {
 function toCanonicalStep(step) {
     switch (step.stepKind) {
         case CONSTANTS.Enums.StepKind.tool: {
-            const { stepKey: _stepKey, toolStepKey: _toolStepKey, ...canonicalToolStep } = step;
+            const { stepKey: _stepKey, ...canonicalToolStep } = step;
             return canonicalToolStep;
         }
         case CONSTANTS.Enums.StepKind.branch: {
-            const { stepKey: _stepKey, macroStepKey: _macroStepKey, cases, ...rest } = step;
+            const { stepKey: _stepKey, cases, ...rest } = step;
             return {
                 ...rest,
                 cases: cases.map(stripMutableCase),
@@ -70,7 +70,7 @@ function toCanonicalStep(step) {
         }
         case CONSTANTS.Enums.StepKind.while:
         case CONSTANTS.Enums.StepKind.for: {
-            const { stepKey: _stepKey, macroStepKey: _macroStepKey, case: stepCase, ...rest } = step;
+            const { stepKey: _stepKey, case: stepCase, ...rest } = step;
             return {
                 ...rest,
                 case: stripMutableCase(stepCase),
@@ -92,7 +92,6 @@ function toMutableStrategyStateEntry(entry, executionKeyByPath) {
         strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
             stepKey: sourceToolStepKey,
-            toolStepKey: sourceToolStepKey,
             roleName: entry.toolStepRoleAddress.roleName,
         },
     };
@@ -102,7 +101,6 @@ function toMutableToolStep(step) {
     return {
         ...step,
         stepKey: key,
-        toolStepKey: key,
     };
 }
 function toMutableCase(stepCase) {
@@ -119,7 +117,6 @@ function toMutableBranchStep(step) {
     return {
         ...rest,
         stepKey: key,
-        macroStepKey: key,
         cases: cases.map(toMutableCase),
     };
 }
@@ -129,7 +126,6 @@ function toMutableWhileStep(step) {
     return {
         ...rest,
         stepKey: key,
-        macroStepKey: key,
         case: toMutableCase(stepCase),
     };
 }
@@ -139,7 +135,6 @@ function toMutableForStep(step) {
     return {
         ...rest,
         stepKey: key,
-        macroStepKey: key,
         case: toMutableCase(stepCase),
     };
 }
@@ -160,8 +155,8 @@ function toMutableStep(step) {
 function buildExecutionKeyMap(strategy) {
     const executionPathByKey = buildExecutionPathMap(strategy);
     const executionKeyByPath = new Map();
-    for (const [toolStepKey, toolStepPath] of executionPathByKey.entries()) {
-        executionKeyByPath.set(toolStepPath, toolStepKey);
+    for (const [stepKey, toolStepPath] of executionPathByKey.entries()) {
+        executionKeyByPath.set(toolStepPath, stepKey);
     }
     return executionKeyByPath;
 }
@@ -175,11 +170,11 @@ export function strategyToMutableStrategy(strategy) {
     const executionKeyByPath = buildExecutionKeyMap(seededMutableStrategy);
     const strategyState = {};
     for (const [toolStepPath, inputEntryByRoleName] of Object.entries(strategy.strategyState)) {
-        const toolStepKey = executionKeyByPath.get(toolStepPath);
-        if (!toolStepKey) {
+        const stepKey = executionKeyByPath.get(toolStepPath);
+        if (!stepKey) {
             throw new Error(`Cannot deproject strategy state: no mutable key found for toolStepPath '${toolStepPath}'.`);
         }
-        strategyState[toolStepKey] = Object.fromEntries(Object.entries(inputEntryByRoleName).map(([roleName, entry]) => {
+        strategyState[stepKey] = Object.fromEntries(Object.entries(inputEntryByRoleName).map(([roleName, entry]) => {
             if (entry === undefined) {
                 throw new Error(`Cannot deproject strategy state: role '${roleName}' on toolStepPath '${toolStepPath}' is explicitly undefined.`);
             }
@@ -198,17 +193,17 @@ export function strategyToMutableStrategy(strategy) {
 export function mutableStrategyToStrategy(mutableStrategy) {
     const executionPathByKey = buildExecutionPathMap(mutableStrategy);
     const strategyState = {};
-    for (const [toolStepKey, inputEntryByRoleName] of Object.entries(mutableStrategy.strategyState)) {
+    for (const [stepKey, inputEntryByRoleName] of Object.entries(mutableStrategy.strategyState)) {
         if (!inputEntryByRoleName) {
             continue;
         }
-        const toolStepPath = executionPathByKey.get(toolStepKey);
+        const toolStepPath = executionPathByKey.get(stepKey);
         if (!toolStepPath) {
-            throw new Error(`Cannot project strategy state: no execution path found for toolStepKey '${toolStepKey}'.`);
+            throw new Error(`Cannot project strategy state: no execution path found for stepKey '${stepKey}'.`);
         }
         strategyState[toolStepPath] = Object.fromEntries(Object.entries(inputEntryByRoleName).map(([roleName, entry]) => {
             if (entry === undefined) {
-                throw new Error(`Cannot project strategy state: role '${roleName}' on toolStepKey '${toolStepKey}' is explicitly undefined.`);
+                throw new Error(`Cannot project strategy state: role '${roleName}' on stepKey '${stepKey}' is explicitly undefined.`);
             }
             return [
                 roleName,
@@ -222,25 +217,25 @@ export function mutableStrategyToStrategy(mutableStrategy) {
         strategyState,
     };
 }
-export function mutableToolStepKeyToToolStepPath(mutableStrategy, toolStepKey) {
+export function mutableStepKeyToToolStepPath(mutableStrategy, stepKey) {
     const executionPathByKey = buildExecutionPathMap(mutableStrategy);
-    const toolStepPath = executionPathByKey.get(toolStepKey);
+    const toolStepPath = executionPathByKey.get(stepKey);
     if (!toolStepPath) {
-        throw new Error(`Cannot project toolStepPath: no execution path found for toolStepKey '${toolStepKey}'.`);
+        throw new Error(`Cannot project toolStepPath: no execution path found for stepKey '${stepKey}'.`);
     }
     return toolStepPath;
 }
-export function projectMutableStrategyStateEntriesByToolStepKeyToCanonicalDelta(mutableStrategy, toolStepKey, entries) {
+export function projectMutableStrategyStateEntriesByStepKeyToCanonicalDelta(mutableStrategy, stepKey, entries) {
     const executionPathByKey = buildExecutionPathMap(mutableStrategy);
-    const toolStepPath = executionPathByKey.get(toolStepKey);
+    const toolStepPath = executionPathByKey.get(stepKey);
     if (!toolStepPath) {
-        throw new Error(`Cannot project strategy state delta: no execution path found for toolStepKey '${toolStepKey}'.`);
+        throw new Error(`Cannot project strategy state delta: no execution path found for stepKey '${stepKey}'.`);
     }
     const canonicalEntries = Object.fromEntries(Object.entries(entries)
         .filter(([, entry]) => entry !== undefined)
         .map(([roleName, entry]) => {
         if (entry === undefined) {
-            throw new Error(`Cannot project strategy state delta: role '${roleName}' on toolStepKey '${toolStepKey}' is explicitly undefined.`);
+            throw new Error(`Cannot project strategy state delta: role '${roleName}' on stepKey '${stepKey}' is explicitly undefined.`);
         }
         return [
             roleName,

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-core/lib",
-  "version": "1.0.48",
+  "version": "1.0.50",
   "description": "",
   "type": "module",
   "keywords": [],