@toolproof-core/lib 1.0.49 → 1.0.51

package/dist/lookups/lookups.d.ts

@@ -42,6 +42,8 @@ export declare const CONSTANTS: {
         readonly InternalInputPotential: "InternalInputPotential";
         readonly JsonScalarLink: "JsonScalarLink";
         readonly JsonSchemaObject: "JsonSchemaObject";
+        readonly MacroStepContext: "MacroStepContext";
+        readonly MacroStepSlot: "MacroStepSlot";
         readonly MaterializedResource: "MaterializedResource";
         readonly Name: "Name";
         readonly NameFacet: "NameFacet";
@@ -96,10 +98,6 @@ export declare const CONSTANTS: {
         readonly Tool: "Tool";
         readonly ToolHandle: "ToolHandle";
         readonly ToolStep: "ToolStep";
-        readonly ToolStepPath: "ToolStepPath";
-        readonly ToolStepPathSlot: "ToolStepPathSlot";
-        readonly ToolStepPathSlotFacet: "ToolStepPathSlotFacet";
-        readonly ToolStepPathSpec: "ToolStepPathSpec";
         readonly ToolStepRoleAddress: "ToolStepRoleAddress";
         readonly TracePoint: "TracePoint";
         readonly TracePointCounterSnapshot: "TracePointCounterSnapshot";

package/dist/utils/mutableStrategyOverlay.d.ts

@@ -1,13 +1,12 @@
-import type { BranchStep, Case, ExternalInputPotential, ForStep, MaterializedResource, InternalInputPotential, Resource, RoleName, Strategy, Tool, ToolHandle, ToolStep, ToolStepRoleAddress, WhileStep } from '@toolproof-core/genesis';
+import type { BranchStep, Case, ExternalInputPotential, ForStep, MaterializedResource, InternalInputPotential, Resource, RoleName, Strategy, Tool, ToolHandle, ToolStep, ToolStepRoleAddress, WhileStep } from '@toolproof-core/genesis/types';
 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 MutableStepKey = MutableToolStepKey | MutableBranchStepKey | MutableLoopStepKey;
 export type MutableMaterializedResource = MaterializedResource;
-export type MutableToolStepRoleAddress = Omit<ToolStepRoleAddress, 'toolStepPath'> & {
+export type MutableToolStepRoleAddress = Omit<ToolStepRoleAddress, 'stepPath'> & {
     stepKey: MutableToolStepKey;
 };
 export type MutableInternalInputPotential = Omit<InternalInputPotential, 'toolStepRoleAddress'> & {
@@ -26,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;

package/dist/utils/stepCreation.js

@@ -33,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,
     };
@@ -49,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,
     };
@@ -57,7 +54,6 @@ export function createBranchStepFromCases(cases) {
 export function cloneForStep(forStep) {
     return {
         stepKey: generateIdentifier('ForStepKey'),
-        macroStepKey: generateIdentifier('ForStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.for,
         case: {
             what: {
@@ -74,7 +70,6 @@ export function cloneForStep(forStep) {
 export function cloneWhileStep(whileStep) {
     return {
         stepKey: generateIdentifier('WhileStepKey'),
-        macroStepKey: generateIdentifier('WhileStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.while,
         case: {
             what: {

package/dist/utils/strategyCanonicalization.d.ts

@@ -1,6 +1,6 @@
-import type { Strategy, ToolStepPath } from '@toolproof-core/genesis';
+import type { Strategy, StepPath } from '@toolproof-core/genesis/types';
 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 mutableStepKeyToToolStepPath(mutableStrategy: MutableStrategy, stepKey: MutableToolStepKey): ToolStepPath;
+export declare function mutableStepKeyToStepPath(mutableStrategy: MutableStrategy, stepKey: MutableToolStepKey): StepPath;
 export declare function projectMutableStrategyStateEntriesByStepKeyToCanonicalDelta(mutableStrategy: MutableStrategy, stepKey: MutableToolStepKey, entries: MutableStrategyStateEntryByRoleName): Strategy['strategyState'];

package/dist/utils/strategyCanonicalization.js

@@ -43,14 +43,14 @@ function toCanonicalStrategyStateEntry(entry, executionPathByKey) {
     if (entry.strategyStateEntryKind !== 'internalInputPotential') {
         return entry;
     }
-    const sourceToolStepPath = executionPathByKey.get(entry.toolStepRoleAddress.stepKey);
-    if (!sourceToolStepPath) {
+    const sourceStepPath = executionPathByKey.get(entry.toolStepRoleAddress.stepKey);
+    if (!sourceStepPath) {
         throw new Error(`Cannot project strategy state: no execution path found for stepKey '${entry.toolStepRoleAddress.stepKey}'.`);
     }
     return {
         strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
-            toolStepPath: sourceToolStepPath,
+            stepPath: sourceStepPath,
             roleName: entry.toolStepRoleAddress.roleName,
         },
     };
@@ -62,7 +62,7 @@ function toCanonicalStep(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),
@@ -84,9 +84,9 @@ function toMutableStrategyStateEntry(entry, executionKeyByPath) {
     if (entry.strategyStateEntryKind !== 'internalInputPotential') {
         return entry;
     }
-    const sourceToolStepKey = executionKeyByPath.get(entry.toolStepRoleAddress.toolStepPath);
+    const sourceToolStepKey = executionKeyByPath.get(entry.toolStepRoleAddress.stepPath);
     if (!sourceToolStepKey) {
-        throw new Error(`Cannot deproject strategy state: no mutable key found for toolStepPath '${entry.toolStepRoleAddress.toolStepPath}'.`);
+        throw new Error(`Cannot deproject strategy state: no mutable key found for stepPath '${entry.toolStepRoleAddress.stepPath}'.`);
     }
     return {
         strategyStateEntryKind: 'internalInputPotential',
@@ -117,7 +117,6 @@ function toMutableBranchStep(step) {
     return {
         ...rest,
         stepKey: key,
-        macroStepKey: key,
         cases: cases.map(toMutableCase),
     };
 }
@@ -127,7 +126,6 @@ function toMutableWhileStep(step) {
     return {
         ...rest,
         stepKey: key,
-        macroStepKey: key,
         case: toMutableCase(stepCase),
     };
 }
@@ -137,7 +135,6 @@ function toMutableForStep(step) {
     return {
         ...rest,
         stepKey: key,
-        macroStepKey: key,
         case: toMutableCase(stepCase),
     };
 }
@@ -158,8 +155,8 @@ function toMutableStep(step) {
 function buildExecutionKeyMap(strategy) {
     const executionPathByKey = buildExecutionPathMap(strategy);
     const executionKeyByPath = new Map();
-    for (const [stepKey, toolStepPath] of executionPathByKey.entries()) {
-        executionKeyByPath.set(toolStepPath, stepKey);
+    for (const [stepKey, stepPath] of executionPathByKey.entries()) {
+        executionKeyByPath.set(stepPath, stepKey);
     }
     return executionKeyByPath;
 }
@@ -172,14 +169,14 @@ 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) {
-            throw new Error(`Cannot deproject strategy state: no mutable key found for toolStepPath '${toolStepPath}'.`);
+    for (const [stepPath, inputEntryByRoleName] of Object.entries(strategy.strategyState)) {
+        const stepKey = executionKeyByPath.get(stepPath);
+        if (!stepKey) {
+            throw new Error(`Cannot deproject strategy state: no mutable key found for stepPath '${stepPath}'.`);
         }
-        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.`);
+                throw new Error(`Cannot deproject strategy state: role '${roleName}' on stepPath '${stepPath}' is explicitly undefined.`);
             }
             return [
                 roleName,
@@ -200,11 +197,11 @@ export function mutableStrategyToStrategy(mutableStrategy) {
         if (!inputEntryByRoleName) {
             continue;
         }
-        const toolStepPath = executionPathByKey.get(stepKey);
-        if (!toolStepPath) {
+        const stepPath = executionPathByKey.get(stepKey);
+        if (!stepPath) {
             throw new Error(`Cannot project strategy state: no execution path found for stepKey '${stepKey}'.`);
         }
-        strategyState[toolStepPath] = Object.fromEntries(Object.entries(inputEntryByRoleName).map(([roleName, entry]) => {
+        strategyState[stepPath] = Object.fromEntries(Object.entries(inputEntryByRoleName).map(([roleName, entry]) => {
             if (entry === undefined) {
                 throw new Error(`Cannot project strategy state: role '${roleName}' on stepKey '${stepKey}' is explicitly undefined.`);
             }
@@ -220,18 +217,18 @@ export function mutableStrategyToStrategy(mutableStrategy) {
         strategyState,
     };
 }
-export function mutableStepKeyToToolStepPath(mutableStrategy, stepKey) {
+export function mutableStepKeyToStepPath(mutableStrategy, stepKey) {
     const executionPathByKey = buildExecutionPathMap(mutableStrategy);
-    const toolStepPath = executionPathByKey.get(stepKey);
-    if (!toolStepPath) {
-        throw new Error(`Cannot project toolStepPath: no execution path found for stepKey '${stepKey}'.`);
+    const stepPath = executionPathByKey.get(stepKey);
+    if (!stepPath) {
+        throw new Error(`Cannot project stepPath: no execution path found for stepKey '${stepKey}'.`);
     }
-    return toolStepPath;
+    return stepPath;
 }
 export function projectMutableStrategyStateEntriesByStepKeyToCanonicalDelta(mutableStrategy, stepKey, entries) {
     const executionPathByKey = buildExecutionPathMap(mutableStrategy);
-    const toolStepPath = executionPathByKey.get(stepKey);
-    if (!toolStepPath) {
+    const stepPath = executionPathByKey.get(stepKey);
+    if (!stepPath) {
         throw new Error(`Cannot project strategy state delta: no execution path found for stepKey '${stepKey}'.`);
     }
     const canonicalEntries = Object.fromEntries(Object.entries(entries)
@@ -246,6 +243,6 @@ export function projectMutableStrategyStateEntriesByStepKeyToCanonicalDelta(muta
         ];
     }));
     return {
-        [toolStepPath]: canonicalEntries,
+        [stepPath]: canonicalEntries,
     };
 }

package/dist/utils/toolStepPaths.d.ts

@@ -1,2 +1,2 @@
-import type { ToolStepPath, ToolStepPathSpec } from '@toolproof-core/genesis';
-export declare function toToolStepPath(spec: ToolStepPathSpec): ToolStepPath;
+import type { StepPath, StepPathSpec } from '@toolproof-core/genesis/types';
+export declare function toStepPath(spec: StepPathSpec): StepPath;

package/dist/utils/toolStepPaths.js

@@ -1,21 +1,13 @@
-function getToolStepPathSuffix(spec) {
-    if (spec.toolStepPathSlot === 'self') {
-        return '/self';
-    }
-    if (spec.toolStepPathSlot === 'cases/when' || spec.toolStepPathSlot === 'cases/what') {
-        if (typeof spec.caseIndex !== 'number') {
-            throw new Error('Expected caseIndex for branch tool-step path construction');
+function getStepPathSuffix(spec) {
+    return spec.segments
+        .map((segment) => {
+        if (segment.segmentKind === 'case') {
+            return `/case/${segment.slot}`;
         }
-        return `/cases/${spec.caseIndex}/${spec.toolStepPathSlot === 'cases/when' ? 'when' : 'what'}`;
-    }
-    if (spec.toolStepPathSlot === 'case/when') {
-        return '/case/when';
-    }
-    if (spec.toolStepPathSlot === 'case/what') {
-        return '/case/what';
-    }
-    throw new Error(`Unsupported tool-step path slot '${String(spec.toolStepPathSlot)}'`);
+        return `/cases/${segment.caseIndex}/${segment.slot}`;
+    })
+        .join('');
 }
-export function toToolStepPath(spec) {
-    return `/threads/${spec.threadIndex}/steps/${spec.stepIndex}${getToolStepPathSuffix(spec)}`;
+export function toStepPath(spec) {
+    return `/threads/${spec.threadIndex}/steps/${spec.stepIndex}${getStepPathSuffix(spec)}`;
 }

package/package.json

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

package/src/utils/mutableStrategyOverlay.ts

@@ -13,7 +13,7 @@ import type {
     ToolStep,
     ToolStepRoleAddress,
     WhileStep,
-} from '@toolproof-core/genesis';
+} from '@toolproof-core/genesis/types';
 import { extractResourceTypeHandleFromRoleValue } from './strategyExtraction.js';
 
 export type MutableToolStepKey = `TOOL_STEP-${string}`;
@@ -21,13 +21,12 @@ 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'> & {
+    Omit<ToolStepRoleAddress, 'stepPath'> & {
         stepKey: MutableToolStepKey;
     };
 
@@ -58,19 +57,16 @@ 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;
 };
 

package/src/utils/stepCreation.ts

@@ -62,7 +62,6 @@ export function createLoopStepFromCase(
     if (stepKind === CONSTANTS.Enums.StepKind.for) {
         return {
             stepKey: generateIdentifier('ForStepKey'),
-            macroStepKey: generateIdentifier('ForStepKey'),
             stepKind: CONSTANTS.Enums.StepKind.for,
             case: stepCase,
         };
@@ -70,7 +69,6 @@ export function createLoopStepFromCase(
 
     return {
         stepKey: generateIdentifier('WhileStepKey'),
-        macroStepKey: generateIdentifier('WhileStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.while,
         case: stepCase,
     };
@@ -83,7 +81,6 @@ export function createBranchStepFromCases(
 
     return {
         stepKey: generateIdentifier('BranchStepKey'),
-        macroStepKey: generateIdentifier('BranchStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.branch,
         cases,
     };
@@ -94,7 +91,6 @@ export function cloneForStep(
 ): MutableForStep {
     return {
         stepKey: generateIdentifier('ForStepKey'),
-        macroStepKey: generateIdentifier('ForStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.for,
         case: {
             what: {
@@ -114,7 +110,6 @@ export function cloneWhileStep(
 ): MutableWhileStep {
     return {
         stepKey: generateIdentifier('WhileStepKey'),
-        macroStepKey: generateIdentifier('WhileStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.while,
         case: {
             what: {

package/src/utils/strategyCanonicalization.ts

@@ -10,9 +10,9 @@ import type {
     Strategy,
     StrategyStateEntry,
     ToolStep,
-    ToolStepPath,
+    StepPath,
     WhileStep,
-} from '@toolproof-core/genesis';
+} from '@toolproof-core/genesis/types';
 import { CONSTANTS } from '../lookups/lookups.js';
 import type {
     MutableBranchStep,
@@ -41,24 +41,24 @@ function stripMutableCase(stepCase: MutableCase): Case {
     };
 }
 
-function buildExecutionPathMap(strategy: MutableStrategy): Map<MutableToolStepKey, ToolStepPath> {
-    const executionPathByKey = new Map<MutableToolStepKey, ToolStepPath>();
+function buildExecutionPathMap(strategy: MutableStrategy): Map<MutableToolStepKey, StepPath> {
+    const executionPathByKey = new Map<MutableToolStepKey, StepPath>();
 
     const registerStep = (step: MutableStep, pathPrefix: string) => {
         switch (step.stepKind) {
             case CONSTANTS.Enums.StepKind.tool:
-                executionPathByKey.set(step.stepKey, `${pathPrefix}/self` as ToolStepPath);
+                executionPathByKey.set(step.stepKey, `${pathPrefix}/self` as StepPath);
                 return;
             case CONSTANTS.Enums.StepKind.branch:
                 step.cases.forEach((stepCase, caseIndex) => {
-                    executionPathByKey.set(stepCase.when.stepKey, `${pathPrefix}/cases/${caseIndex}/when` as ToolStepPath);
-                    executionPathByKey.set(stepCase.what.stepKey, `${pathPrefix}/cases/${caseIndex}/what` as ToolStepPath);
+                    executionPathByKey.set(stepCase.when.stepKey, `${pathPrefix}/cases/${caseIndex}/when` as StepPath);
+                    executionPathByKey.set(stepCase.what.stepKey, `${pathPrefix}/cases/${caseIndex}/what` as StepPath);
                 });
                 return;
             case CONSTANTS.Enums.StepKind.while:
             case CONSTANTS.Enums.StepKind.for:
-                executionPathByKey.set(step.case.when.stepKey, `${pathPrefix}/case/when` as ToolStepPath);
-                executionPathByKey.set(step.case.what.stepKey, `${pathPrefix}/case/what` as ToolStepPath);
+                executionPathByKey.set(step.case.when.stepKey, `${pathPrefix}/case/when` as StepPath);
+                executionPathByKey.set(step.case.what.stepKey, `${pathPrefix}/case/what` as StepPath);
                 return;
             default:
                 throw new Error('Unsupported step kind while projecting strategy.');
@@ -76,21 +76,21 @@ function buildExecutionPathMap(strategy: MutableStrategy): Map<MutableToolStepKe
 
 function toCanonicalStrategyStateEntry(
     entry: MutableStrategyStateEntry,
-    executionPathByKey: ReadonlyMap<MutableToolStepKey, ToolStepPath>,
+    executionPathByKey: ReadonlyMap<MutableToolStepKey, StepPath>,
 ): StrategyStateEntry {
     if (entry.strategyStateEntryKind !== 'internalInputPotential') {
         return entry as MaterializedResource | ExternalInputPotential;
     }
 
-    const sourceToolStepPath = executionPathByKey.get(entry.toolStepRoleAddress.stepKey);
-    if (!sourceToolStepPath) {
+    const sourceStepPath = executionPathByKey.get(entry.toolStepRoleAddress.stepKey);
+    if (!sourceStepPath) {
         throw new Error(`Cannot project strategy state: no execution path found for stepKey '${entry.toolStepRoleAddress.stepKey}'.`);
     }
 
     return {
         strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
-            toolStepPath: sourceToolStepPath,
+            stepPath: sourceStepPath,
             roleName: entry.toolStepRoleAddress.roleName,
         },
     } satisfies InternalInputPotential;
@@ -103,7 +103,7 @@ function toCanonicalStep(step: MutableStep): 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) as [Case, ...Case[]],
@@ -111,7 +111,7 @@ function toCanonicalStep(step: MutableStep): 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),
@@ -124,15 +124,15 @@ function toCanonicalStep(step: MutableStep): Step {
 
 function toMutableStrategyStateEntry(
     entry: StrategyStateEntry,
-    executionKeyByPath: ReadonlyMap<ToolStepPath, MutableToolStepKey>,
+    executionKeyByPath: ReadonlyMap<StepPath, MutableToolStepKey>,
 ): MutableStrategyStateEntry {
     if (entry.strategyStateEntryKind !== 'internalInputPotential') {
         return entry as MaterializedResource | ExternalInputPotential;
     }
 
-    const sourceToolStepKey = executionKeyByPath.get(entry.toolStepRoleAddress.toolStepPath);
+    const sourceToolStepKey = executionKeyByPath.get(entry.toolStepRoleAddress.stepPath);
     if (!sourceToolStepKey) {
-        throw new Error(`Cannot deproject strategy state: no mutable key found for toolStepPath '${entry.toolStepRoleAddress.toolStepPath}'.`);
+        throw new Error(`Cannot deproject strategy state: no mutable key found for stepPath '${entry.toolStepRoleAddress.stepPath}'.`);
     }
 
     return {
@@ -169,7 +169,6 @@ function toMutableBranchStep(step: BranchStep): MutableBranchStep {
     return {
         ...rest,
         stepKey: key,
-        macroStepKey: key,
         cases: cases.map(toMutableCase) as [MutableCase, ...MutableCase[]],
     };
 }
@@ -181,7 +180,6 @@ function toMutableWhileStep(step: WhileStep): MutableWhileStep {
     return {
         ...rest,
         stepKey: key,
-        macroStepKey: key,
         case: toMutableCase(stepCase),
     };
 }
@@ -193,7 +191,6 @@ function toMutableForStep(step: ForStep): MutableForStep {
     return {
         ...rest,
         stepKey: key,
-        macroStepKey: key,
         case: toMutableCase(stepCase),
     };
 }
@@ -213,12 +210,12 @@ function toMutableStep(step: Step): MutableStep {
     }
 }
 
-function buildExecutionKeyMap(strategy: MutableStrategy): Map<ToolStepPath, MutableToolStepKey> {
+function buildExecutionKeyMap(strategy: MutableStrategy): Map<StepPath, MutableToolStepKey> {
     const executionPathByKey = buildExecutionPathMap(strategy);
-    const executionKeyByPath = new Map<ToolStepPath, MutableToolStepKey>();
+    const executionKeyByPath = new Map<StepPath, MutableToolStepKey>();
 
-    for (const [stepKey, toolStepPath] of executionPathByKey.entries()) {
-        executionKeyByPath.set(toolStepPath, stepKey);
+    for (const [stepKey, stepPath] of executionPathByKey.entries()) {
+        executionKeyByPath.set(stepPath, stepKey);
     }
 
     return executionKeyByPath;
@@ -236,17 +233,17 @@ export function strategyToMutableStrategy(strategy: Strategy): MutableStrategy {
     const executionKeyByPath = buildExecutionKeyMap(seededMutableStrategy);
     const strategyState: MutableStrategy['strategyState'] = {};
 
-    for (const [toolStepPath, inputEntryByRoleName] of Object.entries(strategy.strategyState)) {
-        const toolStepKey = executionKeyByPath.get(toolStepPath as ToolStepPath);
-        if (!toolStepKey) {
-            throw new Error(`Cannot deproject strategy state: no mutable key found for toolStepPath '${toolStepPath}'.`);
+    for (const [stepPath, inputEntryByRoleName] of Object.entries(strategy.strategyState)) {
+        const stepKey = executionKeyByPath.get(stepPath as StepPath);
+        if (!stepKey) {
+            throw new Error(`Cannot deproject strategy state: no mutable key found for stepPath '${stepPath}'.`);
         }
 
-        strategyState[toolStepKey] = Object.fromEntries(
+        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.`
+                        `Cannot deproject strategy state: role '${roleName}' on stepPath '${stepPath}' is explicitly undefined.`
                     );
                 }
 
@@ -274,12 +271,12 @@ export function mutableStrategyToStrategy(mutableStrategy: MutableStrategy): Str
             continue;
         }
 
-        const toolStepPath = executionPathByKey.get(stepKey as MutableToolStepKey);
-        if (!toolStepPath) {
+        const stepPath = executionPathByKey.get(stepKey as MutableToolStepKey);
+        if (!stepPath) {
             throw new Error(`Cannot project strategy state: no execution path found for stepKey '${stepKey}'.`);
         }
 
-        strategyState[toolStepPath] = Object.fromEntries(
+        strategyState[stepPath] = Object.fromEntries(
             Object.entries(inputEntryByRoleName).map(([roleName, entry]) => {
                 if (entry === undefined) {
                     throw new Error(
@@ -302,17 +299,17 @@ export function mutableStrategyToStrategy(mutableStrategy: MutableStrategy): Str
     };
 }
 
-export function mutableStepKeyToToolStepPath(
+export function mutableStepKeyToStepPath(
     mutableStrategy: MutableStrategy,
     stepKey: MutableToolStepKey,
-): ToolStepPath {
+): StepPath {
     const executionPathByKey = buildExecutionPathMap(mutableStrategy);
-    const toolStepPath = executionPathByKey.get(stepKey);
-    if (!toolStepPath) {
-        throw new Error(`Cannot project toolStepPath: no execution path found for stepKey '${stepKey}'.`);
+    const stepPath = executionPathByKey.get(stepKey);
+    if (!stepPath) {
+        throw new Error(`Cannot project stepPath: no execution path found for stepKey '${stepKey}'.`);
     }
 
-    return toolStepPath;
+    return stepPath;
 }
 
 export function projectMutableStrategyStateEntriesByStepKeyToCanonicalDelta(
@@ -321,12 +318,12 @@ export function projectMutableStrategyStateEntriesByStepKeyToCanonicalDelta(
     entries: MutableStrategyStateEntryByRoleName,
 ): Strategy['strategyState'] {
     const executionPathByKey = buildExecutionPathMap(mutableStrategy);
-    const toolStepPath = executionPathByKey.get(stepKey);
-    if (!toolStepPath) {
+    const stepPath = executionPathByKey.get(stepKey);
+    if (!stepPath) {
         throw new Error(`Cannot project strategy state delta: no execution path found for stepKey '${stepKey}'.`);
     }
 
-    const canonicalEntries: Strategy['strategyState'][ToolStepPath] = Object.fromEntries(
+    const canonicalEntries: Strategy['strategyState'][StepPath] = Object.fromEntries(
         Object.entries(entries)
             .filter(([, entry]) => entry !== undefined)
             .map(([roleName, entry]) => {
@@ -344,6 +341,6 @@ export function projectMutableStrategyStateEntriesByStepKeyToCanonicalDelta(
     );
 
     return {
-        [toolStepPath]: canonicalEntries,
+        [stepPath]: canonicalEntries,
     };
 }