@toolproof-core/lib 1.0.47 → 1.0.49

package/dist/lookups/lookups.d.ts

@@ -68,6 +68,11 @@ export declare const CONSTANTS: {
         readonly StepArrayArray: "StepArrayArray";
         readonly StepKind: "StepKind";
         readonly StepKindFacet: "StepKindFacet";
+        readonly StepPath: "StepPath";
+        readonly StepPathSegment: "StepPathSegment";
+        readonly StepPathSegmentKind: "StepPathSegmentKind";
+        readonly StepPathSlot: "StepPathSlot";
+        readonly StepPathSpec: "StepPathSpec";
         readonly StepsByThreadIndexFacet: "StepsByThreadIndexFacet";
         readonly StepsFacet: "StepsFacet";
         readonly Strategy: "Strategy";
@@ -189,6 +194,10 @@ export declare const CONSTANTS: {
             readonly while: "while";
             readonly for: "for";
         };
+        readonly StepPathSegmentKind: {
+            readonly case: "case";
+            readonly cases: "cases";
+        };
         readonly StrategyStateEntryKind: {
             readonly materializedResource: "materializedResource";
             readonly externalInputPotential: "externalInputPotential";

package/dist/utils/mutableStrategyOverlay.d.ts

@@ -1,55 +1,58 @@
 import type { BranchStep, Case, ExternalInputPotential, ForStep, MaterializedResource, InternalInputPotential, Resource, RoleName, Strategy, Tool, ToolHandle, ToolStep, ToolStepRoleAddress, WhileStep } from '@toolproof-core/genesis';
-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> = Omit<ToolStepRoleAddress, 'toolStepPath'> & {
-    toolStepKey: TKey;
+export type MutableToolStepRoleAddress = Omit<ToolStepRoleAddress, 'toolStepPath'> & {
+    stepKey: MutableToolStepKey;
 };
-export type MutableInternalInputPotential<TKey extends string = MutableToolStepKey> = Omit<InternalInputPotential, 'toolStepRoleAddress'> & {
-    toolStepRoleAddress: MutableToolStepRoleAddress<TKey>;
+export type MutableInternalInputPotential = Omit<InternalInputPotential, 'toolStepRoleAddress'> & {
+    toolStepRoleAddress: MutableToolStepRoleAddress;
 };
 export type MutableExternalInputPotential = ExternalInputPotential;
-export type MutableStrategyStateEntry<TKey extends string = MutableToolStepKey> = MutableMaterializedResource | MutableInternalInputPotential<TKey> | MutableExternalInputPotential;
-export type MutableStrategyStateEntryByRoleName<TKey extends string = MutableToolStepKey> = Partial<Record<RoleName, MutableStrategyStateEntry<TKey>>>;
-export type MutableStrategyState<TKey extends string = MutableToolStepKey> = Partial<Record<TKey, MutableStrategyStateEntryByRoleName<TKey>>>;
-export type MutableToolStep<TKey extends string = MutableToolStepKey> = ToolStep & {
-    toolStepKey: TKey;
-};
-export type MutableCase<TKey extends string = MutableToolStepKey> = Omit<Case, 'when' | 'what'> & {
-    when: MutableToolStep<TKey>;
-    what: MutableToolStep<TKey>;
-};
-export type MutableBranchStep<TKey extends string = MutableToolStepKey> = Omit<BranchStep, 'cases'> & {
+export type MutableStrategyStateEntry = MutableMaterializedResource | MutableInternalInputPotential | MutableExternalInputPotential;
+export type MutableStrategyStateEntryByRoleName = Partial<Record<RoleName, MutableStrategyStateEntry>>;
+export type MutableStrategyState = Partial<Record<MutableToolStepKey, MutableStrategyStateEntryByRoleName>>;
+export type MutableToolStep = ToolStep & {
+    stepKey: MutableToolStepKey;
+};
+export type MutableCase = Omit<Case, 'when' | 'what'> & {
+    when: MutableToolStep;
+    what: MutableToolStep;
+};
+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>;
-};
-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 declare 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 declare 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 declare function getStrategyStateEntryByRoleName<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepKey: TKey): MutableStrategyStateEntryByRoleName<TKey> | undefined;
-export declare function getStrategyStateEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress<TKey>): MutableStrategyStateEntry<TKey> | undefined;
-export declare function setStrategyStateEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress<TKey>, entry: MutableStrategyStateEntry<TKey>): TStrategyState;
-export declare function clearInputBinding<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress<TKey>): TStrategyState;
-export declare function bindMaterializedResource<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, target: MutableToolStepRoleAddress<TKey>, resource: Resource): TStrategyState;
-export declare function bindInternalInputPotential<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, targetAddress: MutableToolStepRoleAddress<TKey>, sourceAddress: MutableToolStepRoleAddress<TKey>, context: {
-    toolStepByKey: ReadonlyMap<TKey, MutableToolStep<TKey>>;
+    case: MutableCase;
+};
+export type MutableStep = MutableToolStep | MutableBranchStep | MutableWhileStep | MutableForStep;
+export type MutableStrategy = Omit<Strategy, 'stepsByThreadIndex' | 'strategyState'> & {
+    stepsByThreadIndex: MutableStep[][];
+    strategyState: MutableStrategyState;
+};
+export declare function getAuthoringSteps(strategy: MutableStrategy): MutableStep[];
+export declare function setAuthoringSteps(strategy: MutableStrategy, steps: MutableStep[]): MutableStrategy;
+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;
+export declare function bindMaterializedResource(strategyState: MutableStrategyState, target: MutableToolStepRoleAddress, resource: Resource): MutableStrategyState;
+export declare function bindInternalInputPotential(strategyState: MutableStrategyState, targetAddress: MutableToolStepRoleAddress, sourceAddress: MutableToolStepRoleAddress, context: {
+    toolStepByKey: ReadonlyMap<MutableToolStepKey, MutableToolStep>;
     toolMap: ReadonlyMap<ToolHandle, Tool>;
-}): TStrategyState;
-export declare function bindExternalInputPotential<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, target: MutableToolStepRoleAddress<TKey>): TStrategyState;
+}): MutableStrategyState;
+export declare function bindExternalInputPotential(strategyState: MutableStrategyState, target: 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,19 +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: {
-            toolStepKey: sourceAddress.toolStepKey,
+            stepKey: sourceAddress.stepKey,
             roleName: sourceAddress.roleName,
         },
     });

package/dist/utils/stepCreation.js

@@ -14,7 +14,7 @@ function getRoleBindingSpec(tool) {
 }
 export function createToolStepFromTool(tool) {
     return {
-        toolStepKey: generateIdentifier('ToolStepKey'),
+        stepKey: generateIdentifier('ToolStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.tool,
         toolHandle: tool.handle,
         roleBindingSpec: getRoleBindingSpec(tool),
@@ -32,12 +32,14 @@ export function createCaseFromToolStepPair(what, when) {
 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,
@@ -46,6 +48,7 @@ export function createLoopStepFromCase(stepCase, stepKind) {
 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,
@@ -53,32 +56,34 @@ 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'),
             },
         },
     };
 }
 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/stepExpansion.d.ts

@@ -1,6 +1,6 @@
-import type { MutableStep, MutableToolStep, MutableToolStepKey } from './mutableStrategyOverlay.js';
+import type { MutableStep, MutableToolStep } from './mutableStrategyOverlay.js';
 export type StepExpansionOrder = {
     branchCaseOrder?: 'when-what' | 'what-when';
     loopCaseOrder?: 'what-when' | 'when-what';
 };
-export declare function extractToolStepsFromStep<TKey extends string = MutableToolStepKey, TStep extends MutableStep<TKey> = MutableStep<TKey>>(step: TStep, order?: StepExpansionOrder): MutableToolStep<TKey>[];
+export declare function extractToolStepsFromStep(step: MutableStep, order?: StepExpansionOrder): MutableToolStep[];

package/dist/utils/stepExpansion.js

@@ -5,28 +5,28 @@ export function extractToolStepsFromStep(step, order = {}) {
         return [step];
     }
     if (step.stepKind === CONSTANTS.Enums.StepKind.branch) {
-        const branch = step;
-        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);
+        });
     }
     if (step.stepKind === CONSTANTS.Enums.StepKind.while) {
-        const loop = step;
+        const whileStep = step;
         if (loopCaseOrder === 'when-what') {
-            return [loop.case.when, loop.case.what].filter(Boolean);
+            return [whileStep.case.when, whileStep.case.what];
         }
-        return [loop.case.what, loop.case.when].filter(Boolean);
+        return [whileStep.case.what, whileStep.case.when];
     }
     if (step.stepKind === CONSTANTS.Enums.StepKind.for) {
-        const loop = step;
+        const forStep = step;
         if (loopCaseOrder === 'when-what') {
-            return [loop.case.when, loop.case.what].filter(Boolean);
+            return [forStep.case.when, forStep.case.what];
         }
-        return [loop.case.what, loop.case.when].filter(Boolean);
+        return [forStep.case.what, forStep.case.when];
     }
     return [];
 }

package/dist/utils/stepParallelization.d.ts

@@ -1,2 +1,2 @@
-import type { MutableStep, MutableStrategyState, MutableToolStepKey } from './mutableStrategyOverlay.js';
-export declare function getIndependentThreads<TKey extends string = MutableToolStepKey, TStep extends MutableStep<TKey> = MutableStep<TKey>>(steps: TStep[], strategyState: MutableStrategyState<TKey>): TStep[][];
+import type { MutableStep, MutableStrategyState } from './mutableStrategyOverlay.js';
+export declare function getIndependentThreads(steps: MutableStep[], strategyState: MutableStrategyState): MutableStep[][];

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/strategyAssembly.d.ts

@@ -1,3 +1,3 @@
 import type { Strategy } from '@toolproof-core/genesis';
 import type { MutableStrategy } from './mutableStrategyOverlay.js';
-export declare function composeStrategyForExecution<TKey extends string>(mutableStrategy: MutableStrategy<TKey>): Strategy;
+export declare function composeStrategyForExecution(mutableStrategy: MutableStrategy): Strategy;

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 { toolStepKey: _whenToolStepKey, ...canonicalWhen } = when;
-    const { 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 { toolStepKey: _toolStepKey, ...canonicalToolStep } = step;
+            const { stepKey: _stepKey, ...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),
@@ -70,7 +70,7 @@ function toCanonicalStep(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),
@@ -91,15 +91,16 @@ function toMutableStrategyStateEntry(entry, executionKeyByPath) {
     return {
         strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
-            toolStepKey: sourceToolStepKey,
+            stepKey: sourceToolStepKey,
             roleName: entry.toolStepRoleAddress.roleName,
         },
     };
 }
 function toMutableToolStep(step) {
+    const key = generateIdentifier('ToolStepKey');
     return {
         ...step,
-        toolStepKey: generateIdentifier('ToolStepKey'),
+        stepKey: key,
     };
 }
 function toMutableCase(stepCase) {
@@ -112,25 +113,31 @@ function toMutableCase(stepCase) {
 }
 function toMutableBranchStep(step) {
     const { cases, ...rest } = step;
+    const key = generateIdentifier('BranchStepKey');
     return {
         ...rest,
-        macroStepKey: generateIdentifier('BranchStepKey'),
+        stepKey: key,
+        macroStepKey: key,
         cases: cases.map(toMutableCase),
     };
 }
 function toMutableWhileStep(step) {
     const { case: stepCase, ...rest } = step;
+    const key = generateIdentifier('WhileStepKey');
     return {
         ...rest,
-        macroStepKey: generateIdentifier('WhileStepKey'),
+        stepKey: key,
+        macroStepKey: key,
         case: toMutableCase(stepCase),
     };
 }
 function toMutableForStep(step) {
     const { case: stepCase, ...rest } = step;
+    const key = generateIdentifier('ForStepKey');
     return {
         ...rest,
-        macroStepKey: generateIdentifier('ForStepKey'),
+        stepKey: key,
+        macroStepKey: key,
         case: toMutableCase(stepCase),
     };
 }
@@ -151,8 +158,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;
 }
@@ -189,17 +196,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,
@@ -213,25 +220,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,