@toolproof-core/lib 1.0.33 → 1.0.36

package/dist/utils/creation/resourceCreation.js

@@ -1,66 +1,67 @@
-export function generatePath(resourceTypeId, id) {
-    return `${resourceTypeId}/${id}.json`;
-}
-export function createMaterializedFromOutputPotential(outputPotential, nucleus, timestamp) {
-    const { id, resourceTypeId, creationContext } = outputPotential;
-    const path = generatePath(resourceTypeId, id);
+export function createExternalInputPotential() {
     return {
-        id,
-        resourceTypeId,
-        provenance: {
-            resourceProvenanceKind: 'strategy',
-            strategyRunId: outputPotential.strategyRunId ?? 'STRATEGY_RUN-UNKNOWN',
-            creationContext,
-        },
-        version: 1,
-        timestamp: timestamp ?? new Date().toISOString(),
-        path,
-        nucleus,
+        strategyStateInputKind: 'externalInputPotential',
     };
 }
-export function createMaterializedFromInputPotential(inputPotential, nucleus, timestamp) {
-    const { id, resourceTypeId, creationContext } = inputPotential;
-    const path = generatePath(resourceTypeId, id);
+export function createInternalInputPotential(toolStepRoleAddress) {
     return {
-        id,
-        resourceTypeId,
-        provenance: {
-            resourceProvenanceKind: 'strategy',
-            strategyRunId: inputPotential.strategyRunId ?? 'STRATEGY_RUN-UNKNOWN',
-            creationContext,
-        },
-        version: 1,
-        timestamp: timestamp ?? new Date().toISOString(),
-        path,
-        nucleus,
+        strategyStateInputKind: 'internalInputPotential',
+        toolStepRoleAddress,
     };
 }
-export function createMaterializedFromPotential(potential, nucleus, timestamp) {
-    if ('strategyStateInputKind' in potential && potential.strategyStateInputKind === 'referenceInput') {
-        return createMaterializedFromInputPotential(potential, nucleus, timestamp);
-    }
-    return createMaterializedFromOutputPotential(potential, nucleus, timestamp);
+export function createStrategyProvenance(strategyTraceHandle, toolStepRoleAddress) {
+    return {
+        provenanceKind: 'strategy',
+        strategyTraceHandle,
+        toolStepRoleAddress,
+    };
 }
-export function createExternalInputPotential(_id, _resourceTypeId) {
+export function createRuntimeProvenance() {
     return {
-        strategyStateInputKind: 'externalInput',
+        provenanceKind: 'runtime',
     };
 }
-export function createInputPotential(id, resourceTypeId, creationContext) {
+export function createResourcePointer(id, resourceTypeHandle, provenance) {
     return {
         id,
-        resourceTypeId,
-        strategyStateInputKind: 'referenceInput',
-        toolStepPath: creationContext.toolStepPath,
-        roleName: creationContext.roleName,
-        creationContext,
+        resourceTypeHandle,
+        provenance,
     };
 }
-export function createOutputPotential(id, resourceTypeId, creationContext) {
+export function createResource(resourcePointer, projection) {
+    return {
+        ...resourcePointer,
+        projection,
+    };
+}
+export function createMaterializedFromOutputPotential(outputPotential, projection) {
+    const provenance = outputPotential.provenanceKind === 'runtime'
+        ? createRuntimeProvenance()
+        : createStrategyProvenance(requireStrategyTraceHandle(outputPotential.strategyTraceHandle), requireToolStepRoleAddress(outputPotential.toolStepRoleAddress));
+    const resourcePointer = createResourcePointer(outputPotential.id, outputPotential.resourceTypeHandle, provenance);
+    return createResource(resourcePointer, projection);
+}
+export function createMaterializedFromPotential(outputPotential, projection) {
+    return createMaterializedFromOutputPotential(outputPotential, projection);
+}
+export function createOutputPotential(id, resourceTypeHandle, toolStepRoleAddress, strategyTraceHandle, provenanceKind) {
     return {
         id,
-        resourceTypeId,
-        creationContext,
+        resourceTypeHandle,
+        ...(toolStepRoleAddress ? { toolStepRoleAddress } : {}),
+        ...(strategyTraceHandle ? { strategyTraceHandle } : {}),
+        ...(provenanceKind ? { provenanceKind } : {}),
     };
 }
-//# sourceMappingURL=resourceCreation.js.map
+function requireStrategyTraceHandle(strategyTraceHandle) {
+    if (!strategyTraceHandle) {
+        throw new Error('strategyTraceHandle is required to materialize a strategy output potential');
+    }
+    return strategyTraceHandle;
+}
+function requireToolStepRoleAddress(toolStepRoleAddress) {
+    if (!toolStepRoleAddress) {
+        throw new Error('toolStepRoleAddress is required to materialize a strategy output potential');
+    }
+    return toolStepRoleAddress;
+}

package/dist/utils/creation/stepCreation.d.ts

@@ -1,51 +1,10 @@
-import type { BranchStep, ForStep, Tool, ToolStep, WhileStep } from '@toolproof-core/schema';
-import { CONSTANTS } from '../../artifacts/artifacts.js';
-type ToolStepId = string;
-type BranchStepId = string;
-type ForStepId = string;
-type WhileStepId = string;
-type ToolStepWithId = ToolStep & {
-    id: ToolStepId;
-};
-type BranchStepWithId = BranchStep & {
-    id: BranchStepId;
-};
-type ForStepWithId = ForStep & {
-    id: ForStepId;
-};
-type WhileStepWithId = WhileStep & {
-    id: WhileStepId;
-};
-export type LoopStepBuildIdentities = {
-    stepKind: typeof CONSTANTS.Enums.StepKind.for;
-    stepId: ForStepId;
-    whatId: ToolStepId;
-    whenId: ToolStepId;
-} | {
-    stepKind: typeof CONSTANTS.Enums.StepKind.while;
-    stepId: WhileStepId;
-    whatId: ToolStepId;
-    whenId: ToolStepId;
-};
-export type BranchCaseBuildIdentities = {
-    whatId: ToolStepId;
-    whenId: ToolStepId;
-};
-export declare function buildToolStepFromTool(tool: Tool, id: ToolStepId): ToolStepWithId;
-export declare function buildLoopStepFromToolPair(whatTool: Tool, whenTool: Tool, identities: LoopStepBuildIdentities): ForStep | WhileStep;
+import type { BranchStep, ForStep, Tool, ToolStep, WhileStep } from '@toolproof-core/genesis';
+import { CONSTANTS } from '../../lookups/lookups.js';
+export declare function buildToolStepFromTool(tool: Tool): ToolStep;
+export declare function buildLoopStepFromToolPair(whatTool: Tool, whenTool: Tool, stepKind: typeof CONSTANTS.Enums.StepKind.for | typeof CONSTANTS.Enums.StepKind.while): ForStep | WhileStep;
 export declare function buildBranchStepFromToolPairs(cases: Array<{
     whatTool: Tool;
     whenTool: Tool;
-}>, branchId: BranchStepId, caseIdentities: BranchCaseBuildIdentities[]): BranchStepWithId;
-export declare function cloneForStepWithIdentities(forStep: ForStep, identities: {
-    stepId: ForStepId;
-    whatId: ToolStepId;
-    whenId: ToolStepId;
-}): ForStepWithId;
-export declare function cloneWhileStepWithIdentities(whileStep: WhileStep, identities: {
-    stepId: WhileStepId;
-    whatId: ToolStepId;
-    whenId: ToolStepId;
-}): WhileStepWithId;
-export {};
-//# sourceMappingURL=stepCreation.d.ts.map
+}>): BranchStep;
+export declare function cloneForStep(forStep: ForStep): ForStep;
+export declare function cloneWhileStep(whileStep: WhileStep): WhileStep;

package/dist/utils/creation/stepCreation.js

@@ -1,4 +1,4 @@
-import { CONSTANTS } from '../../artifacts/artifacts.js';
+import { CONSTANTS } from '../../lookups/lookups.js';
 import { getInputRoleNames, getOutputRoleNames } from '../roleSpec.js';
 function assertNonEmpty(arr, msg) {
     if (arr.length === 0) {
@@ -11,80 +11,54 @@ function getRoleBindingSpec(tool) {
         outputBindings: getOutputRoleNames(tool),
     };
 }
-export function buildToolStepFromTool(tool, id) {
+export function buildToolStepFromTool(tool) {
     return {
-        id,
         stepKind: CONSTANTS.Enums.StepKind.tool,
-        toolId: tool.id,
+        toolHandle: tool.handle,
         roleBindingSpec: getRoleBindingSpec(tool),
     };
 }
-export function buildLoopStepFromToolPair(whatTool, whenTool, identities) {
-    const what = buildToolStepFromTool(whatTool, identities.whatId);
-    const when = buildToolStepFromTool(whenTool, identities.whenId);
-    if (identities.stepKind === CONSTANTS.Enums.StepKind.for) {
+export function buildLoopStepFromToolPair(whatTool, whenTool, stepKind) {
+    const what = buildToolStepFromTool(whatTool);
+    const when = buildToolStepFromTool(whenTool);
+    if (stepKind === CONSTANTS.Enums.StepKind.for) {
         return {
-            id: identities.stepId,
             stepKind: CONSTANTS.Enums.StepKind.for,
             case: { what, when },
         };
     }
     return {
-        id: identities.stepId,
         stepKind: CONSTANTS.Enums.StepKind.while,
         case: { what, when },
     };
 }
-export function buildBranchStepFromToolPairs(cases, branchId, caseIdentities) {
-    if (cases.length !== caseIdentities.length) {
-        throw new Error('buildBranchStepFromToolPairs requires one id pair per case');
-    }
+export function buildBranchStepFromToolPairs(cases) {
     const resolved = cases.map(({ whatTool, whenTool }, index) => {
-        const identities = caseIdentities[index];
-        if (!identities) {
-            throw new Error(`Missing case identities for case index ${index}`);
-        }
-        const what = buildToolStepFromTool(whatTool, identities.whatId);
-        const when = buildToolStepFromTool(whenTool, identities.whenId);
+        const what = buildToolStepFromTool(whatTool);
+        const when = buildToolStepFromTool(whenTool);
         return { what, when };
     });
     assertNonEmpty(resolved, 'buildBranchStepFromToolPairs requires at least one case');
     return {
-        id: branchId,
         stepKind: CONSTANTS.Enums.StepKind.branch,
         cases: resolved,
     };
 }
-export function cloneForStepWithIdentities(forStep, identities) {
+export function cloneForStep(forStep) {
     return {
-        id: identities.stepId,
         stepKind: CONSTANTS.Enums.StepKind.for,
         case: {
-            what: {
-                ...forStep.case.what,
-                id: identities.whatId,
-            },
-            when: {
-                ...forStep.case.when,
-                id: identities.whenId,
-            },
+            what: { ...forStep.case.what },
+            when: { ...forStep.case.when },
         },
     };
 }
-export function cloneWhileStepWithIdentities(whileStep, identities) {
+export function cloneWhileStep(whileStep) {
     return {
-        id: identities.stepId,
         stepKind: CONSTANTS.Enums.StepKind.while,
         case: {
-            what: {
-                ...whileStep.case.what,
-                id: identities.whatId,
-            },
-            when: {
-                ...whileStep.case.when,
-                id: identities.whenId,
-            },
+            what: { ...whileStep.case.what },
+            when: { ...whileStep.case.when },
         },
     };
 }
-//# sourceMappingURL=stepCreation.js.map

package/dist/utils/creation/threadedStrategyCreation.d.ts

@@ -0,0 +1,18 @@
+import type { Step, StrategyHandle } from '@toolproof-core/genesis';
+import { CONSTANTS } from '../../lookups/lookups.js';
+export type ThreadableStrategy<TStrategyState = unknown> = {
+    handle: StrategyHandle;
+    strategyState: TStrategyState;
+} & ({
+    steps: Step[];
+} | {
+    stepsByThreadIndex: Step[][];
+});
+export type ThreadedStrategyLike<TStrategyState = unknown> = {
+    handle: StrategyHandle;
+    strategyKind: typeof CONSTANTS.Enums.StrategyKind.threaded;
+    stepsByThreadIndex: Step[][];
+    strategyState: TStrategyState;
+};
+export declare function getThreadedStrategyStepGroups<TStrategyState>(strategy: ThreadableStrategy<TStrategyState>): Step[][];
+export declare function buildThreadedStrategy<TStrategyState>(threadStepGroups: Step[][], threadedStrategyHandle: StrategyHandle, strategy: ThreadableStrategy<TStrategyState>): ThreadedStrategyLike<TStrategyState>;

package/dist/utils/creation/threadedStrategyCreation.js

@@ -0,0 +1,16 @@
+import { getIndependentThreads } from '../parallelizeSteps.js';
+import { CONSTANTS } from '../../lookups/lookups.js';
+export function getThreadedStrategyStepGroups(strategy) {
+    if ('steps' in strategy) {
+        return getIndependentThreads(strategy.steps, strategy.strategyState);
+    }
+    return strategy.stepsByThreadIndex;
+}
+export function buildThreadedStrategy(threadStepGroups, threadedStrategyHandle, strategy) {
+    return {
+        handle: threadedStrategyHandle,
+        strategyKind: CONSTANTS.Enums.StrategyKind.threaded,
+        stepsByThreadIndex: threadStepGroups,
+        strategyState: strategy.strategyState,
+    };
+}

package/dist/utils/extractData.d.ts

@@ -1,13 +1,12 @@
-import type { RoleName, Strategy, ToolId, Tool, ToolStep, ResourceId, ResourceTypeId, Resource } from '@toolproof-core/schema';
-import { type ToolRoleDescriptor } from './roleSpec.js';
-export declare function extractToolIdsFromRawStrategy(rawStrategy: Strategy): ToolId[];
-export declare function extractToolStepsFromRawStrategy(rawStrategy: Strategy): ToolStep[];
-export declare function extractRoleMapFromRawStrategy(rawStrategy: Strategy, toolMap: Map<ToolId, Tool>): Map<RoleName, ToolRoleDescriptor>;
-export declare function extractSingleNonErrorOutputTypeId(tool: Tool): ResourceTypeId | null;
-export declare function extractResourceMapForType<TResource extends Resource = Resource>(resourcesByType: Partial<Record<ResourceTypeId, TResource[]>>, resourceTypeId: ResourceTypeId): Map<ResourceId, TResource>;
-export declare function extractIdKeyedNucleusMapForType<TKey extends string = string, TNucleus extends {
+import type { RoleName, ToolHandle, Tool, ToolStep, ResourceId, ResourceTypeHandle, Resource } from '@toolproof-core/genesis';
+import { type StrategyStepGraph, type ToolRoleDescriptor } from './roleSpec.js';
+export declare function extractToolHandlesFromUnthreadedStrategy(unthreadedStrategy: StrategyStepGraph): ToolHandle[];
+export declare function extractToolStepsFromUnthreadedStrategy(unthreadedStrategy: StrategyStepGraph): ToolStep[];
+export declare function extractRoleMapFromUnthreadedStrategy(unthreadedStrategy: StrategyStepGraph, toolMap: Map<ToolHandle, Tool>): Map<RoleName, ToolRoleDescriptor>;
+export declare function extractSingleNonErrorOutputTypeId(tool: Tool): ResourceTypeHandle | null;
+export declare function extractResourceMapForType<TResource extends Resource = Resource>(resourcesByType: Partial<Record<ResourceTypeHandle, TResource[]>>, resourceTypeHandle: ResourceTypeHandle): Map<ResourceId, TResource>;
+export declare function extractIdKeyedValueMapForType<TKey extends string = string, TValue extends {
     id: string | number | boolean;
 } = {
     id: string | number | boolean;
-}, TResource extends Resource = Resource>(resourcesByType: Partial<Record<ResourceTypeId, TResource[]>>, resourceTypeId: ResourceTypeId): Map<TKey, TNucleus>;
-//# sourceMappingURL=extractData.d.ts.map
+}, TResource extends Resource = Resource>(resourcesByType: Partial<Record<ResourceTypeHandle, TResource[]>>, resourceTypeHandle: ResourceTypeHandle): Map<TKey, TValue>;

package/dist/utils/extractData.js

@@ -1,21 +1,28 @@
-import { CONSTANTS } from '../artifacts/artifacts.js';
 import { extractToolStepsFromStrategy, getInputRoleEntries, getOutputRoleEntries, toToolRoleDescriptor, } from './roleSpec.js';
-export function extractToolIdsFromRawStrategy(rawStrategy) {
-    const toolSteps = extractToolStepsFromRawStrategy(rawStrategy);
+const ERROR_OUTPUT_ROLE_NAME = 'ErrorOutput';
+function extractResourceTypeHandleFromRoleValue(toolRoleValue) {
+    const typeRef = toolRoleValue.typeRef;
+    if ('resourceTypeHandle' in typeRef) {
+        return typeRef.resourceTypeHandle;
+    }
+    return null;
+}
+export function extractToolHandlesFromUnthreadedStrategy(unthreadedStrategy) {
+    const toolSteps = extractToolStepsFromUnthreadedStrategy(unthreadedStrategy);
     const ids = new Set();
     for (const jStep of toolSteps) {
-        ids.add(jStep.toolId);
+        ids.add(jStep.toolHandle);
     }
     return Array.from(ids);
 }
-export function extractToolStepsFromRawStrategy(rawStrategy) {
-    return extractToolStepsFromStrategy(rawStrategy);
+export function extractToolStepsFromUnthreadedStrategy(unthreadedStrategy) {
+    return extractToolStepsFromStrategy(unthreadedStrategy);
 }
-export function extractRoleMapFromRawStrategy(rawStrategy, toolMap) {
+export function extractRoleMapFromUnthreadedStrategy(unthreadedStrategy, toolMap) {
     const roleMap = new Map();
-    const toolIds = extractToolIdsFromRawStrategy(rawStrategy);
-    for (const toolId of toolIds) {
-        const tool = toolMap.get(toolId);
+    const toolHandles = extractToolHandlesFromUnthreadedStrategy(unthreadedStrategy);
+    for (const toolHandle of toolHandles) {
+        const tool = toolMap.get(toolHandle);
         if (!tool)
             continue;
         for (const entry of getInputRoleEntries(tool)) {
@@ -28,16 +35,14 @@ export function extractRoleMapFromRawStrategy(rawStrategy, toolMap) {
     return roleMap;
 }
 export function extractSingleNonErrorOutputTypeId(tool) {
-    const errorRoleId = CONSTANTS.Cosmos.ROLE_ErrorOutput;
-    const outputEntries = getOutputRoleEntries(tool).filter(([roleName]) => roleName !== errorRoleId);
+    const outputEntries = getOutputRoleEntries(tool).filter(([roleName]) => roleName !== ERROR_OUTPUT_ROLE_NAME);
     if (!outputEntries || !outputEntries[0] || outputEntries.length !== 1) {
-        throw new Error(`Tool ${tool.id} must have exactly one non-error output role to be branchable/loopable`);
+        throw new Error(`Tool ${tool.handle} must have exactly one non-error output role to be branchable/loopable`);
     } // ATTENTION_PUREIFY
-    const outputRole = outputEntries[0][1];
-    return outputRole.resourceTypeId;
+    return extractResourceTypeHandleFromRoleValue(toToolRoleDescriptor(outputEntries[0]));
 }
-export function extractResourceMapForType(resourcesByType, resourceTypeId) {
-    const resources = resourcesByType[resourceTypeId] ?? [];
+export function extractResourceMapForType(resourcesByType, resourceTypeHandle) {
+    const resources = resourcesByType[resourceTypeHandle] ?? [];
     const map = new Map();
     for (const resource of resources) {
         map.set(resource.id, resource);
@@ -45,25 +50,25 @@ export function extractResourceMapForType(resourcesByType, resourceTypeId) {
     return map;
 }
 // Only use this for resource types whose nuclei are entity-like objects with their own intrinsic id.
-export function extractIdKeyedNucleusMapForType(resourcesByType, resourceTypeId) {
-    const resourceMap = extractResourceMapForType(resourcesByType, resourceTypeId);
+export function extractIdKeyedValueMapForType(resourcesByType, resourceTypeHandle) {
+    const resourceMap = extractResourceMapForType(resourcesByType, resourceTypeHandle);
     const out = new Map();
     for (const resource of resourceMap.values()) {
-        const data = resource.nucleus;
+        const data = resource.projection;
         if (data === null || data === undefined) {
-            throw new Error(`Expected resource '${resource.id}' of type '${resourceTypeId}' to have a nucleus`);
+            throw new Error(`Expected resource '${resource.id}' of type '${resourceTypeHandle}' to have a projection`);
         }
         if (typeof data !== 'object') {
-            throw new Error(`Expected resource '${resource.id}' of type '${resourceTypeId}' to have an object nucleus with id`);
+            throw new Error(`Expected resource '${resource.id}' of type '${resourceTypeHandle}' to have an object projection with id`);
         }
         const maybeId = data.id;
         if (maybeId === null || maybeId === undefined) {
-            throw new Error(`Expected resource '${resource.id}' of type '${resourceTypeId}' to have nucleus.id`);
+            throw new Error(`Expected resource '${resource.id}' of type '${resourceTypeHandle}' to have projection.id`);
         }
         if (typeof maybeId !== 'string' &&
             typeof maybeId !== 'number' &&
             typeof maybeId !== 'boolean') {
-            throw new Error(`Expected resource '${resource.id}' of type '${resourceTypeId}' to have nucleus.id as string, number, or boolean`);
+            throw new Error(`Expected resource '${resource.id}' of type '${resourceTypeHandle}' to have projection.id as string, number, or boolean`);
         }
         const value = data;
         const key = String(maybeId);
@@ -71,4 +76,3 @@ export function extractIdKeyedNucleusMapForType(resourcesByType, resourceTypeId)
     }
     return out;
 }
-//# sourceMappingURL=extractData.js.map

package/dist/utils/parallelizeSteps.d.ts

@@ -1,4 +1,3 @@
-import type { Step } from '@toolproof-core/schema';
+import type { Step } from '@toolproof-core/genesis';
 import type { StrategyState } from './strategyState.js';
 export declare function getIndependentThreads(steps: Step[], strategyState: StrategyState): Step[][];
-//# sourceMappingURL=parallelizeSteps.d.ts.map

package/dist/utils/parallelizeSteps.js

@@ -1,53 +1,69 @@
-import { CONSTANTS } from '../artifacts/artifacts.js';
-function getToolStepId(toolStep) {
-    const maybeId = toolStep?.id;
-    return typeof maybeId === 'string' ? maybeId : undefined;
+import { CONSTANTS } from '../lookups/lookups.js';
+function toUnthreadedToolStepPath(opts) {
+    const base = `/steps/${opts.stepIndex}`;
+    switch (opts.toolStepSlot) {
+        case 'self':
+            return `${base}/self`;
+        case 'case.when':
+            return `${base}/case/when`;
+        case 'case.what':
+            return `${base}/case/what`;
+        case 'cases.when':
+            if (typeof opts.caseIndex !== 'number') {
+                throw new Error('Expected caseIndex for cases.when path');
+            }
+            return `${base}/cases/${opts.caseIndex}/when`;
+        case 'cases.what':
+            if (typeof opts.caseIndex !== 'number') {
+                throw new Error('Expected caseIndex for cases.what path');
+            }
+            return `${base}/cases/${opts.caseIndex}/what`;
+        default: {
+            const _exhaustive = opts.toolStepSlot;
+            return _exhaustive;
+        }
+    }
 }
 export function getIndependentThreads(steps, strategyState) {
     const getOwnerLabel = (ownerIndex) => {
         const step = steps[ownerIndex];
         return `steps[${ownerIndex}] stepKind=${step?.stepKind ?? 'unknown'}`;
     };
-    // Map each toolStep.id (including macro-nested tool steps) to owning top-level step index.
-    const toolStepIdToOwner = new Map();
-    const ownerToToolStepIds = new Map();
-    const toolStepById = new Map();
-    const addToolStep = (toolStep, ownerIndex) => {
-        const toolStepId = getToolStepId(toolStep);
-        if (!toolStepId || !toolStep)
+    // Map each canonical toolStepPath (including macro-nested tool steps) to its owning top-level step index.
+    const toolStepPathToOwner = new Map();
+    const toolStepByPath = new Map();
+    const addToolStep = (toolStep, ownerIndex, toolStepPath) => {
+        if (!toolStep)
             return;
-        const existingOwner = toolStepIdToOwner.get(toolStepId);
+        const existingOwner = toolStepPathToOwner.get(toolStepPath);
         if (existingOwner !== undefined) {
-            throw new Error(`Duplicate toolStep.id '${toolStepId}' found in ${getOwnerLabel(ownerIndex)} and ${getOwnerLabel(existingOwner)}`);
+            throw new Error(`Duplicate toolStepPath '${toolStepPath}' found in ${getOwnerLabel(ownerIndex)} and ${getOwnerLabel(existingOwner)}`);
         }
-        toolStepIdToOwner.set(toolStepId, ownerIndex);
-        toolStepById.set(toolStepId, toolStep);
-        const bucket = ownerToToolStepIds.get(ownerIndex) ?? [];
-        bucket.push(toolStepId);
-        ownerToToolStepIds.set(ownerIndex, bucket);
+        toolStepPathToOwner.set(toolStepPath, ownerIndex);
+        toolStepByPath.set(toolStepPath, toolStep);
     };
     steps.forEach((step, ownerIndex) => {
         if (step.stepKind === CONSTANTS.Enums.StepKind.tool) {
-            addToolStep(step, ownerIndex);
+            addToolStep(step, ownerIndex, toUnthreadedToolStepPath({ stepIndex: ownerIndex, toolStepSlot: 'self' }));
             return;
         }
         if (step.stepKind === CONSTANTS.Enums.StepKind.for) {
             const loop = step;
-            addToolStep(loop.case?.what, ownerIndex);
-            addToolStep(loop.case?.when, ownerIndex);
+            addToolStep(loop.case?.what, ownerIndex, toUnthreadedToolStepPath({ stepIndex: ownerIndex, toolStepSlot: 'case.what' }));
+            addToolStep(loop.case?.when, ownerIndex, toUnthreadedToolStepPath({ stepIndex: ownerIndex, toolStepSlot: 'case.when' }));
             return;
         }
         if (step.stepKind === CONSTANTS.Enums.StepKind.while) {
             const loop = step;
-            addToolStep(loop.case?.what, ownerIndex);
-            addToolStep(loop.case?.when, ownerIndex);
+            addToolStep(loop.case?.what, ownerIndex, toUnthreadedToolStepPath({ stepIndex: ownerIndex, toolStepSlot: 'case.what' }));
+            addToolStep(loop.case?.when, ownerIndex, toUnthreadedToolStepPath({ stepIndex: ownerIndex, toolStepSlot: 'case.when' }));
             return;
         }
         if (step.stepKind === CONSTANTS.Enums.StepKind.branch) {
             const branch = step;
-            for (const caseItem of branch.cases ?? []) {
-                addToolStep(caseItem?.what, ownerIndex);
-                addToolStep(caseItem?.when, ownerIndex);
+            for (const [caseIndex, caseItem] of (branch.cases ?? []).entries()) {
+                addToolStep(caseItem?.what, ownerIndex, toUnthreadedToolStepPath({ stepIndex: ownerIndex, toolStepSlot: 'cases.what', caseIndex }));
+                addToolStep(caseItem?.when, ownerIndex, toUnthreadedToolStepPath({ stepIndex: ownerIndex, toolStepSlot: 'cases.when', caseIndex }));
             }
             return;
         }
@@ -66,24 +82,24 @@ export function getIndependentThreads(steps, strategyState) {
         ensureOwner(i);
     }
     // Discover dependencies from strategyState.
-    for (const [toolStepId, ownerIndex] of toolStepIdToOwner) {
+    for (const [toolStepPath, ownerIndex] of toolStepPathToOwner) {
         ensureOwner(ownerIndex);
-        const toolStep = toolStepById.get(toolStepId);
+        const toolStep = toolStepByPath.get(toolStepPath);
         const inputBindings = toolStep?.roleBindingSpec?.inputBindings ?? [];
-        const bucket = strategyState?.[toolStepId] ?? {};
+        const bucket = strategyState?.[toolStepPath] ?? {};
         for (const inputRoleId of inputBindings) {
             const entry = bucket?.[inputRoleId];
-            if (!entry || entry.strategyStateInputKind !== 'referenceInput')
+            if (!entry || entry.strategyStateInputKind !== 'internalInputPotential')
                 continue;
-            const creatorToolStepId = typeof entry?.toolStepPath === 'string'
-                ? entry.toolStepPath
+            const creatorToolStepPath = typeof entry?.toolStepRoleAddress?.toolStepPath === 'string'
+                ? entry.toolStepRoleAddress.toolStepPath
                 : undefined;
-            if (!creatorToolStepId) {
-                throw new Error(`Unresolvable referenceInput in toolStep '${toolStepId}' (${getOwnerLabel(ownerIndex)}): missing toolStepPath for role '${inputRoleId}'`);
+            if (!creatorToolStepPath) {
+                throw new Error(`Unresolvable internalInputPotential in toolStep '${toolStepPath}' (${getOwnerLabel(ownerIndex)}): missing toolStepRoleAddress.toolStepPath for role '${inputRoleId}'`);
             }
-            const producerOwner = toolStepIdToOwner.get(creatorToolStepId);
+            const producerOwner = toolStepPathToOwner.get(creatorToolStepPath);
             if (producerOwner === undefined) {
-                throw new Error(`Unresolvable referenceInput in toolStep '${toolStepId}' (${getOwnerLabel(ownerIndex)}): creator toolStepPath '${creatorToolStepId}' not found in strategy steps`);
+                throw new Error(`Unresolvable internalInputPotential in toolStep '${toolStepPath}' (${getOwnerLabel(ownerIndex)}): source toolStepPath '${creatorToolStepPath}' not found in strategy steps`);
             }
             ensureOwner(producerOwner);
             ownerAdj.get(ownerIndex).add(producerOwner);
@@ -141,4 +157,3 @@ export function getIndependentThreads(steps, strategyState) {
     })
         .filter((group) => group.length > 0);
 }
-//# sourceMappingURL=parallelizeSteps.js.map

package/dist/utils/resolveStrategyStateChain.d.ts

@@ -0,0 +1,20 @@
+import type { ToolStepRoleAddress, ExternalInputPotential, InputResource, ThreadedStrategyState, ThreadedToolStepRoleAddress, UnthreadedStrategyState, UnthreadedToolStepRoleAddress } from '@toolproof-core/genesis';
+import { type StrategyState } from './strategyState.js';
+type ToolStepRoleAddressForStrategyState<TStrategyState extends StrategyState> = TStrategyState extends UnthreadedStrategyState ? UnthreadedToolStepRoleAddress : TStrategyState extends ThreadedStrategyState ? ThreadedToolStepRoleAddress : ToolStepRoleAddress;
+export type ResolveResult = {
+    status: 'inputResource';
+    entry: InputResource;
+    path: ToolStepRoleAddress[];
+} | {
+    status: 'externalInputPotential';
+    entry: ExternalInputPotential;
+    path: ToolStepRoleAddress[];
+} | {
+    status: 'unresolved';
+    reason: 'not-found' | 'cycle' | 'depth-exceeded';
+    path: ToolStepRoleAddress[];
+};
+export declare function resolveStrategyStateChain<TStrategyState extends StrategyState>(strategyState: TStrategyState, start: ToolStepRoleAddressForStrategyState<TStrategyState>, opts?: {
+    maxDepth?: number;
+}): ResolveResult;
+export {};

package/dist/utils/{resolveResourceChain.js → resolveStrategyStateChain.js}

@@ -1,5 +1,5 @@
 import { getStrategyStateEntry } from './strategyState.js';
-export function resolveResourceChain(strategyState, start, opts) {
+export function resolveStrategyStateChain(strategyState, start, opts) {
     const maxDepth = opts?.maxDepth ?? 50;
     const visited = new Set();
     const path = [];
@@ -14,18 +14,13 @@ export function resolveResourceChain(strategyState, start, opts) {
         const entry = getStrategyStateEntry(strategyState, current);
         if (!entry)
             return { status: 'unresolved', reason: 'not-found', path };
-        if (entry.strategyStateInputKind === 'valueInput') {
-            return { status: 'valueInput', entry: entry, path };
+        if (entry.strategyStateInputKind === 'inputResource') {
+            return { status: 'inputResource', entry, path };
         }
-        if (entry.strategyStateInputKind === 'externalInput') {
-            return { status: 'externalInput', entry: entry, path };
+        if (entry.strategyStateInputKind === 'externalInputPotential') {
+            return { status: 'externalInputPotential', entry, path };
         }
-        current = {
-            toolStepPath: entry.toolStepPath,
-            roleName: entry.roleName,
-        };
-        continue;
+        current = entry.toolStepRoleAddress;
     }
     return { status: 'unresolved', reason: 'depth-exceeded', path };
 }
-//# sourceMappingURL=resolveResourceChain.js.map