@toolproof-core/lib 1.0.37 → 1.0.39

package/dist/lookups/lookups.d.ts

@@ -37,10 +37,10 @@ export declare const CONSTANTS: {
         readonly Goal: "Goal";
         readonly GoalHandle: "GoalHandle";
         readonly InputPotential: "InputPotential";
-        readonly InputResource: "InputResource";
         readonly InternalInputPotential: "InternalInputPotential";
         readonly JsonScalarLink: "JsonScalarLink";
         readonly JsonSchemaObject: "JsonSchemaObject";
+        readonly MaterializedResource: "MaterializedResource";
         readonly Name: "Name";
         readonly NameFacet: "NameFacet";
         readonly Natural: "Natural";
@@ -75,10 +75,10 @@ export declare const CONSTANTS: {
         readonly StrategyProvenance: "StrategyProvenance";
         readonly StrategyStartTracePoint: "StrategyStartTracePoint";
         readonly StrategyState: "StrategyState";
+        readonly StrategyStateEntry: "StrategyStateEntry";
+        readonly StrategyStateEntryByRoleName: "StrategyStateEntryByRoleName";
+        readonly StrategyStateEntryKind: "StrategyStateEntryKind";
         readonly StrategyStateFacet: "StrategyStateFacet";
-        readonly StrategyStateInputEntry: "StrategyStateInputEntry";
-        readonly StrategyStateInputEntryByRoleName: "StrategyStateInputEntryByRoleName";
-        readonly StrategyStateInputKind: "StrategyStateInputKind";
         readonly StrategyTrace: "StrategyTrace";
         readonly StrategyTraceHandle: "StrategyTraceHandle";
         readonly Suite: "Suite";
@@ -185,8 +185,8 @@ export declare const CONSTANTS: {
             readonly while: "while";
             readonly for: "for";
         };
-        readonly StrategyStateInputKind: {
-            readonly inputResource: "inputResource";
+        readonly StrategyStateEntryKind: {
+            readonly materializedResource: "materializedResource";
             readonly externalInputPotential: "externalInputPotential";
             readonly internalInputPotential: "internalInputPotential";
         };

package/dist/utils/mutableStrategyOverlay.d.ts

@@ -1,11 +1,11 @@
-import type { BranchStep, Case, ExternalInputPotential, ForStep, InputResource, 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';
 export type MutableToolStepKey = string;
 export type MutableBranchStepKey = string;
 export type MutableWhileStepKey = string;
 export type MutableForStepKey = string;
 export type MutableLoopStepKey = MutableWhileStepKey | MutableForStepKey;
 export type MutableMacroStepKey = MutableBranchStepKey | MutableLoopStepKey;
-export type MutableInputResource = InputResource;
+export type MutableMaterializedResource = MaterializedResource;
 export type MutableToolStepRoleAddress<TKey extends string = MutableToolStepKey> = Omit<ToolStepRoleAddress, 'toolStepPath'> & {
     toolStepKey: TKey;
 };
@@ -13,9 +13,9 @@ export type MutableInternalInputPotential<TKey extends string = MutableToolStepK
     toolStepRoleAddress: MutableToolStepRoleAddress<TKey>;
 };
 export type MutableExternalInputPotential = ExternalInputPotential;
-export type MutableStrategyStateInputEntry<TKey extends string = MutableToolStepKey> = MutableInputResource | MutableInternalInputPotential<TKey> | MutableExternalInputPotential;
-export type MutableStrategyStateInputEntryByRoleName<TKey extends string = MutableToolStepKey> = Partial<Record<RoleName, MutableStrategyStateInputEntry<TKey>>>;
-export type MutableStrategyState<TKey extends string = MutableToolStepKey> = Partial<Record<TKey, MutableStrategyStateInputEntryByRoleName<TKey>>>;
+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;
 };
@@ -43,11 +43,11 @@ export type MutableStrategy<TKey extends string = MutableToolStepKey, TStep exte
 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 getStrategyStateInputEntryByRoleName<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepKey: TKey): MutableStrategyStateInputEntryByRoleName<TKey> | undefined;
-export declare function getStrategyStateInputEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress<TKey>): MutableStrategyStateInputEntry<TKey> | undefined;
-export declare function setStrategyStateInputEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress<TKey>, entry: MutableStrategyStateInputEntry<TKey>): TStrategyState;
+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 bindInputResource<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, target: MutableToolStepRoleAddress<TKey>, resource: Resource): 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>>;
     toolMap: ReadonlyMap<ToolHandle, Tool>;

package/dist/utils/mutableStrategyOverlay.js

@@ -10,15 +10,15 @@ export function setAuthoringSteps(strategy, steps) {
         stepsByThreadIndex: nextStepsByThreadIndex,
     };
 }
-export function getStrategyStateInputEntryByRoleName(strategyState, toolStepKey) {
+export function getStrategyStateEntryByRoleName(strategyState, toolStepKey) {
     return strategyState[toolStepKey];
 }
-export function getStrategyStateInputEntry(strategyState, toolStepRoleAddress) {
-    const inputEntryByRoleName = getStrategyStateInputEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey);
+export function getStrategyStateEntry(strategyState, toolStepRoleAddress) {
+    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey);
     return inputEntryByRoleName?.[toolStepRoleAddress.roleName];
 }
-export function setStrategyStateInputEntry(strategyState, toolStepRoleAddress, entry) {
-    const inputEntryByRoleName = getStrategyStateInputEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey) ?? {};
+export function setStrategyStateEntry(strategyState, toolStepRoleAddress, entry) {
+    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey) ?? {};
     return {
         ...strategyState,
         [toolStepRoleAddress.toolStepKey]: {
@@ -28,7 +28,7 @@ export function setStrategyStateInputEntry(strategyState, toolStepRoleAddress, e
     };
 }
 export function clearInputBinding(strategyState, toolStepRoleAddress) {
-    const inputEntryByRoleName = getStrategyStateInputEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey);
+    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey);
     if (!inputEntryByRoleName || !(toolStepRoleAddress.roleName in inputEntryByRoleName)) {
         return strategyState;
     }
@@ -44,12 +44,12 @@ export function clearInputBinding(strategyState, toolStepRoleAddress) {
         [toolStepRoleAddress.toolStepKey]: nextInputEntryByRoleName,
     };
 }
-export function bindInputResource(strategyState, target, resource) {
-    const mutableInputResource = {
+export function bindMaterializedResource(strategyState, target, resource) {
+    const mutableMaterializedResource = {
         ...resource,
-        strategyStateInputKind: 'inputResource',
+        strategyStateEntryKind: 'materializedResource',
     };
-    return setStrategyStateInputEntry(strategyState, target, mutableInputResource);
+    return setStrategyStateEntry(strategyState, target, mutableMaterializedResource);
 }
 function getInputRoleValue(tool, roleName) {
     return tool.roleSpec.inputRoleValueByName[roleName];
@@ -99,8 +99,8 @@ export function bindInternalInputPotential(strategyState, targetAddress, sourceA
     if (!sourceRoleType || !targetRoleType || sourceRoleType !== targetRoleType) {
         throw new Error(`Reference type mismatch between source (${sourceAddress.toolStepKey}, ${sourceAddress.roleName}) and target (${targetAddress.toolStepKey}, ${targetAddress.roleName}).`);
     }
-    return setStrategyStateInputEntry(strategyState, targetAddress, {
-        strategyStateInputKind: 'internalInputPotential',
+    return setStrategyStateEntry(strategyState, targetAddress, {
+        strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
             toolStepKey: sourceAddress.toolStepKey,
             roleName: sourceAddress.roleName,
@@ -109,7 +109,7 @@ export function bindInternalInputPotential(strategyState, targetAddress, sourceA
 }
 export function bindExternalInputPotential(strategyState, target) {
     const mutableExternalInputPotential = {
-        strategyStateInputKind: 'externalInputPotential',
+        strategyStateEntryKind: 'externalInputPotential',
     };
-    return setStrategyStateInputEntry(strategyState, target, mutableExternalInputPotential);
+    return setStrategyStateEntry(strategyState, target, mutableExternalInputPotential);
 }

package/dist/utils/stepParallelization.js

@@ -59,7 +59,7 @@ export function getIndependentThreads(steps, strategyState) {
         const bucket = strategyState[toolStepKey];
         for (const inputRoleId of inputBindings) {
             const entry = bucket?.[inputRoleId];
-            if (!entry || entry.strategyStateInputKind !== 'internalInputPotential')
+            if (!entry || entry.strategyStateEntryKind !== 'internalInputPotential')
                 continue;
             const producerToolStepKey = entry.toolStepRoleAddress?.toolStepKey;
             if (typeof producerToolStepKey !== 'string') {

package/dist/utils/strategyCanonicalization.d.ts

@@ -1,4 +1,6 @@
-import type { Strategy } from '@toolproof-core/genesis';
-import type { MutableStrategy } from './mutableStrategyOverlay.js';
+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 projectMutableRoleEntriesByToolStepKeyToCanonicalDelta(mutableStrategy: MutableStrategy, toolStepKey: MutableToolStepKey, roleEntries: MutableStrategyStateEntryByRoleName): Strategy['strategyState'];

package/dist/utils/strategyCanonicalization.js

@@ -40,7 +40,7 @@ function buildExecutionPathMap(strategy) {
     return executionPathByKey;
 }
 function toCanonicalStrategyStateEntry(entry, executionPathByKey) {
-    if (entry.strategyStateInputKind !== 'internalInputPotential') {
+    if (entry.strategyStateEntryKind !== 'internalInputPotential') {
         return entry;
     }
     const sourceToolStepPath = executionPathByKey.get(entry.toolStepRoleAddress.toolStepKey);
@@ -48,7 +48,7 @@ function toCanonicalStrategyStateEntry(entry, executionPathByKey) {
         throw new Error(`Cannot project strategy state: no execution path found for toolStepKey '${entry.toolStepRoleAddress.toolStepKey}'.`);
     }
     return {
-        strategyStateInputKind: 'internalInputPotential',
+        strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
             toolStepPath: sourceToolStepPath,
             roleName: entry.toolStepRoleAddress.roleName,
@@ -81,7 +81,7 @@ function toCanonicalStep(step) {
     }
 }
 function toMutableStrategyStateEntry(entry, executionKeyByPath) {
-    if (entry.strategyStateInputKind !== 'internalInputPotential') {
+    if (entry.strategyStateEntryKind !== 'internalInputPotential') {
         return entry;
     }
     const sourceToolStepKey = executionKeyByPath.get(entry.toolStepRoleAddress.toolStepPath);
@@ -89,7 +89,7 @@ function toMutableStrategyStateEntry(entry, executionKeyByPath) {
         throw new Error(`Cannot deproject strategy state: no mutable key found for toolStepPath '${entry.toolStepRoleAddress.toolStepPath}'.`);
     }
     return {
-        strategyStateInputKind: 'internalInputPotential',
+        strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
             toolStepKey: sourceToolStepKey,
             roleName: entry.toolStepRoleAddress.roleName,
@@ -213,3 +213,32 @@ export function mutableStrategyToStrategy(mutableStrategy) {
         strategyState,
     };
 }
+export function mutableToolStepKeyToToolStepPath(mutableStrategy, toolStepKey) {
+    const executionPathByKey = buildExecutionPathMap(mutableStrategy);
+    const toolStepPath = executionPathByKey.get(toolStepKey);
+    if (!toolStepPath) {
+        throw new Error(`Cannot project toolStepPath: no execution path found for toolStepKey '${toolStepKey}'.`);
+    }
+    return toolStepPath;
+}
+export function projectMutableRoleEntriesByToolStepKeyToCanonicalDelta(mutableStrategy, toolStepKey, roleEntries) {
+    const executionPathByKey = buildExecutionPathMap(mutableStrategy);
+    const toolStepPath = executionPathByKey.get(toolStepKey);
+    if (!toolStepPath) {
+        throw new Error(`Cannot project strategy state delta: no execution path found for toolStepKey '${toolStepKey}'.`);
+    }
+    const canonicalRoleEntries = Object.fromEntries(Object.entries(roleEntries)
+        .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.`);
+        }
+        return [
+            roleName,
+            toCanonicalStrategyStateEntry(entry, executionPathByKey),
+        ];
+    }));
+    return {
+        [toolStepPath]: canonicalRoleEntries,
+    };
+}

package/dist/utils/strategyStateResolution.d.ts

@@ -1,7 +1,7 @@
-import type { MutableInputResource, MutableExternalInputPotential, MutableStrategyState, MutableToolStepKey, MutableToolStepRoleAddress } from './mutableStrategyOverlay.js';
+import type { MutableMaterializedResource, MutableExternalInputPotential, MutableStrategyState, MutableToolStepKey, MutableToolStepRoleAddress } from './mutableStrategyOverlay.js';
 export type ResolveResult<TKey extends string = MutableToolStepKey> = {
-    status: 'inputResource';
-    entry: MutableInputResource;
+    status: 'materializedResource';
+    entry: MutableMaterializedResource;
     path: MutableToolStepRoleAddress<TKey>[];
 } | {
     status: 'externalInputPotential';

package/dist/utils/strategyStateResolution.js

@@ -1,4 +1,4 @@
-import { getStrategyStateInputEntry } from './mutableStrategyOverlay.js';
+import { getStrategyStateEntry } from './mutableStrategyOverlay.js';
 export function resolveStrategyStateChain(strategyState, start, opts) {
     const maxDepth = opts?.maxDepth ?? 50;
     const visited = new Set();
@@ -11,14 +11,14 @@ export function resolveStrategyStateChain(strategyState, start, opts) {
             return { status: 'unresolved', reason: 'cycle', path };
         }
         visited.add(visitKey);
-        const entry = getStrategyStateInputEntry(strategyState, current);
+        const entry = getStrategyStateEntry(strategyState, current);
         if (!entry) {
             return { status: 'unresolved', reason: 'not-found', path };
         }
-        if (entry.strategyStateInputKind === 'inputResource') {
-            return { status: 'inputResource', entry, path };
+        if (entry.strategyStateEntryKind === 'materializedResource') {
+            return { status: 'materializedResource', entry, path };
         }
-        if (entry.strategyStateInputKind === 'externalInputPotential') {
+        if (entry.strategyStateEntryKind === 'externalInputPotential') {
             return { status: 'externalInputPotential', entry, path };
         }
         current = entry.toolStepRoleAddress;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-core/lib",
-  "version": "1.0.37",
+  "version": "1.0.39",
   "description": "",
   "type": "module",
   "keywords": [],
@@ -72,7 +72,7 @@
     "@types/node": "^22.0.0"
   },
   "dependencies": {
-    "@toolproof-core/genesis": "^1.0.58",
+    "@toolproof-core/genesis": "^1.0.60",
     "firebase-admin": "^13.7.0"
   },
   "scripts": {

package/src/utils/mutableStrategyOverlay.ts

@@ -3,7 +3,7 @@ import type {
     Case,
     ExternalInputPotential,
     ForStep,
-    InputResource,
+    MaterializedResource,
     InternalInputPotential,
     Resource,
     RoleName,
@@ -23,7 +23,7 @@ export type MutableForStepKey = string;
 export type MutableLoopStepKey = MutableWhileStepKey | MutableForStepKey;
 export type MutableMacroStepKey = MutableBranchStepKey | MutableLoopStepKey;
 
-export type MutableInputResource = InputResource;
+export type MutableMaterializedResource = MaterializedResource;
 
 export type MutableToolStepRoleAddress<TKey extends string = MutableToolStepKey> =
     Omit<ToolStepRoleAddress, 'toolStepPath'> & {
@@ -37,18 +37,18 @@ export type MutableInternalInputPotential<TKey extends string = MutableToolStepK
 
 export type MutableExternalInputPotential = ExternalInputPotential;
 
-export type MutableStrategyStateInputEntry<TKey extends string = MutableToolStepKey> =
-    | MutableInputResource
+export type MutableStrategyStateEntry<TKey extends string = MutableToolStepKey> =
+    | MutableMaterializedResource
     | MutableInternalInputPotential<TKey>
     | MutableExternalInputPotential;
 
-export type MutableStrategyStateInputEntryByRoleName<
+export type MutableStrategyStateEntryByRoleName<
     TKey extends string = MutableToolStepKey,
-> = Partial<Record<RoleName, MutableStrategyStateInputEntry<TKey>>>;
+> = Partial<Record<RoleName, MutableStrategyStateEntry<TKey>>>;
 
 export type MutableStrategyState<
     TKey extends string = MutableToolStepKey,
-> = Partial<Record<TKey, MutableStrategyStateInputEntryByRoleName<TKey>>>;
+> = Partial<Record<TKey, MutableStrategyStateEntryByRoleName<TKey>>>;
 
 export type MutableToolStep<TKey extends string = MutableToolStepKey> = ToolStep & {
     toolStepKey: TKey;
@@ -116,27 +116,27 @@ export function setAuthoringSteps< // ATTENTION
     };
 }
 
-export function getStrategyStateInputEntryByRoleName<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
+export function getStrategyStateEntryByRoleName<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
     strategyState: TStrategyState,
     toolStepKey: TKey,
-): MutableStrategyStateInputEntryByRoleName<TKey> | undefined {
+): MutableStrategyStateEntryByRoleName<TKey> | undefined {
     return strategyState[toolStepKey];
 }
 
-export function getStrategyStateInputEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
+export function getStrategyStateEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
     strategyState: TStrategyState,
     toolStepRoleAddress: MutableToolStepRoleAddress<TKey>,
-): MutableStrategyStateInputEntry<TKey> | undefined {
-    const inputEntryByRoleName = getStrategyStateInputEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey);
+): MutableStrategyStateEntry<TKey> | undefined {
+    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey);
     return inputEntryByRoleName?.[toolStepRoleAddress.roleName];
 }
 
-export function setStrategyStateInputEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
+export function setStrategyStateEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
     strategyState: TStrategyState,
     toolStepRoleAddress: MutableToolStepRoleAddress<TKey>,
-    entry: MutableStrategyStateInputEntry<TKey>,
+    entry: MutableStrategyStateEntry<TKey>,
 ): TStrategyState {
-    const inputEntryByRoleName = getStrategyStateInputEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey) ?? {};
+    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey) ?? {};
 
     return {
         ...strategyState,
@@ -155,7 +155,7 @@ export function clearInputBinding<
     toolStepRoleAddress: MutableToolStepRoleAddress<TKey>,
 ): TStrategyState {
     const inputEntryByRoleName =
-        getStrategyStateInputEntryByRoleName(
+        getStrategyStateEntryByRoleName(
             strategyState,
             toolStepRoleAddress.toolStepKey,
         );
@@ -179,17 +179,17 @@ export function clearInputBinding<
     };
 }
 
-export function bindInputResource<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
+export function bindMaterializedResource<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
     strategyState: TStrategyState,
     target: MutableToolStepRoleAddress<TKey>,
     resource: Resource,
 ): TStrategyState {
-    const mutableInputResource: MutableInputResource = {
+    const mutableMaterializedResource: MutableMaterializedResource = {
         ...resource,
-        strategyStateInputKind: 'inputResource',
+        strategyStateEntryKind: 'materializedResource',
     };
 
-    return setStrategyStateInputEntry(strategyState, target, mutableInputResource);
+    return setStrategyStateEntry(strategyState, target, mutableMaterializedResource);
 }
 
 function getInputRoleValue(tool: Tool, roleName: RoleName) {
@@ -265,8 +265,8 @@ export function bindInternalInputPotential<TKey extends string, TStrategyState e
         );
     }
 
-    return setStrategyStateInputEntry(strategyState, targetAddress, {
-        strategyStateInputKind: 'internalInputPotential',
+    return setStrategyStateEntry(strategyState, targetAddress, {
+        strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
             toolStepKey: sourceAddress.toolStepKey,
             roleName: sourceAddress.roleName,
@@ -279,8 +279,8 @@ export function bindExternalInputPotential<TKey extends string, TStrategyState e
     target: MutableToolStepRoleAddress<TKey>,
 ): TStrategyState {
     const mutableExternalInputPotential: MutableExternalInputPotential = {
-        strategyStateInputKind: 'externalInputPotential',
+        strategyStateEntryKind: 'externalInputPotential',
     };
 
-    return setStrategyStateInputEntry(strategyState, target, mutableExternalInputPotential);
+    return setStrategyStateEntry(strategyState, target, mutableExternalInputPotential);
 }

package/src/utils/stepParallelization.ts

@@ -93,7 +93,7 @@ export function getIndependentThreads<
 
 		for (const inputRoleId of inputBindings) {
 			const entry = bucket?.[inputRoleId];
-			if (!entry || entry.strategyStateInputKind !== 'internalInputPotential') continue;
+			if (!entry || entry.strategyStateEntryKind !== 'internalInputPotential') continue;
 
 			const producerToolStepKey = entry.toolStepRoleAddress?.toolStepKey;
 			if (typeof producerToolStepKey !== 'string') {

package/src/utils/strategyCanonicalization.ts

@@ -3,12 +3,12 @@ import type {
     Case,
     ExternalInputPotential,
     ForStep,
-    InputResource,
+    MaterializedResource,
     InternalInputPotential,
     RoleName,
     Step,
     Strategy,
-    StrategyStateInputEntry,
+    StrategyStateEntry,
     ToolStep,
     ToolStepPath,
     WhileStep,
@@ -21,7 +21,8 @@ import type {
     MutableInternalInputPotential,
     MutableStrategy,
     MutableStep,
-    MutableStrategyStateInputEntry,
+    MutableStrategyStateEntryByRoleName,
+    MutableStrategyStateEntry,
     MutableToolStepKey,
     MutableWhileStep,
 } from './mutableStrategyOverlay.js';
@@ -73,11 +74,11 @@ function buildExecutionPathMap(strategy: MutableStrategy): Map<MutableToolStepKe
 }
 
 function toCanonicalStrategyStateEntry(
-    entry: MutableStrategyStateInputEntry,
+    entry: MutableStrategyStateEntry,
     executionPathByKey: ReadonlyMap<MutableToolStepKey, ToolStepPath>,
-): StrategyStateInputEntry {
-    if (entry.strategyStateInputKind !== 'internalInputPotential') {
-        return entry as InputResource | ExternalInputPotential;
+): StrategyStateEntry {
+    if (entry.strategyStateEntryKind !== 'internalInputPotential') {
+        return entry as MaterializedResource | ExternalInputPotential;
     }
 
     const sourceToolStepPath = executionPathByKey.get(entry.toolStepRoleAddress.toolStepKey);
@@ -86,7 +87,7 @@ function toCanonicalStrategyStateEntry(
     }
 
     return {
-        strategyStateInputKind: 'internalInputPotential',
+        strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
             toolStepPath: sourceToolStepPath,
             roleName: entry.toolStepRoleAddress.roleName,
@@ -121,11 +122,11 @@ function toCanonicalStep(step: MutableStep): Step {
 }
 
 function toMutableStrategyStateEntry(
-    entry: StrategyStateInputEntry,
+    entry: StrategyStateEntry,
     executionKeyByPath: ReadonlyMap<ToolStepPath, MutableToolStepKey>,
-): MutableStrategyStateInputEntry {
-    if (entry.strategyStateInputKind !== 'internalInputPotential') {
-        return entry as InputResource | ExternalInputPotential;
+): MutableStrategyStateEntry {
+    if (entry.strategyStateEntryKind !== 'internalInputPotential') {
+        return entry as MaterializedResource | ExternalInputPotential;
     }
 
     const sourceToolStepKey = executionKeyByPath.get(entry.toolStepRoleAddress.toolStepPath);
@@ -134,7 +135,7 @@ function toMutableStrategyStateEntry(
     }
 
     return {
-        strategyStateInputKind: 'internalInputPotential',
+        strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
             toolStepKey: sourceToolStepKey,
             roleName: entry.toolStepRoleAddress.roleName,
@@ -291,4 +292,50 @@ export function mutableStrategyToStrategy(mutableStrategy: MutableStrategy): Str
         stepsByThreadIndex: mutableStrategy.stepsByThreadIndex.map((steps) => steps.map(toCanonicalStep)),
         strategyState,
     };
+}
+
+export function mutableToolStepKeyToToolStepPath(
+    mutableStrategy: MutableStrategy,
+    toolStepKey: MutableToolStepKey,
+): ToolStepPath {
+    const executionPathByKey = buildExecutionPathMap(mutableStrategy);
+    const toolStepPath = executionPathByKey.get(toolStepKey);
+    if (!toolStepPath) {
+        throw new Error(`Cannot project toolStepPath: no execution path found for toolStepKey '${toolStepKey}'.`);
+    }
+
+    return toolStepPath;
+}
+
+export function projectMutableRoleEntriesByToolStepKeyToCanonicalDelta(
+    mutableStrategy: MutableStrategy,
+    toolStepKey: MutableToolStepKey,
+    roleEntries: MutableStrategyStateEntryByRoleName,
+): Strategy['strategyState'] {
+    const executionPathByKey = buildExecutionPathMap(mutableStrategy);
+    const toolStepPath = executionPathByKey.get(toolStepKey);
+    if (!toolStepPath) {
+        throw new Error(`Cannot project strategy state delta: no execution path found for toolStepKey '${toolStepKey}'.`);
+    }
+
+    const canonicalRoleEntries: Strategy['strategyState'][ToolStepPath] = Object.fromEntries(
+        Object.entries(roleEntries)
+            .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.`
+                    );
+                }
+
+                return [
+                    roleName as RoleName,
+                    toCanonicalStrategyStateEntry(entry, executionPathByKey),
+                ] as const;
+            })
+    );
+
+    return {
+        [toolStepPath]: canonicalRoleEntries,
+    };
 }

package/src/utils/strategyStateResolution.ts

@@ -1,16 +1,16 @@
 import type {
-	MutableInputResource,
+	MutableMaterializedResource,
 	MutableExternalInputPotential,
 	MutableInternalInputPotential,
 	MutableStrategyState,
-	MutableStrategyStateInputEntry,
+	MutableStrategyStateEntry,
 	MutableToolStepKey,
 	MutableToolStepRoleAddress,
 } from './mutableStrategyOverlay.js';
-import { getStrategyStateInputEntry } from './mutableStrategyOverlay.js';
+import { getStrategyStateEntry } from './mutableStrategyOverlay.js';
 
 export type ResolveResult<TKey extends string = MutableToolStepKey> =
-	| { status: 'inputResource'; entry: MutableInputResource; path: MutableToolStepRoleAddress<TKey>[] }
+	| { status: 'materializedResource'; entry: MutableMaterializedResource; path: MutableToolStepRoleAddress<TKey>[] }
 	| { status: 'externalInputPotential'; entry: MutableExternalInputPotential; path: MutableToolStepRoleAddress<TKey>[] }
 	| {
 		status: 'unresolved';
@@ -37,16 +37,16 @@ export function resolveStrategyStateChain<TKey extends string, TStrategyState ex
 		}
 		visited.add(visitKey);
 
-		const entry = getStrategyStateInputEntry(strategyState, current) as MutableStrategyStateInputEntry<TKey> | undefined;
+		const entry = getStrategyStateEntry(strategyState, current) as MutableStrategyStateEntry<TKey> | undefined;
 		if (!entry) {
 			return { status: 'unresolved', reason: 'not-found', path };
 		}
 
-		if (entry.strategyStateInputKind === 'inputResource') {
-			return { status: 'inputResource', entry, path };
+		if (entry.strategyStateEntryKind === 'materializedResource') {
+			return { status: 'materializedResource', entry, path };
 		}
 
-		if (entry.strategyStateInputKind === 'externalInputPotential') {
+		if (entry.strategyStateEntryKind === 'externalInputPotential') {
 			return { status: 'externalInputPotential', entry, path };
 		}