@toolproof-core/lib 1.0.33 → 1.0.36

package/src/utils/parallelizeSteps.ts

@@ -1,19 +1,44 @@
 import type {
     BranchStep,
     ForStep,
+    ToolStepPath,
     ToolStep,
     Step,
     WhileStep,
-} from '@toolproof-core/schema';
-import { CONSTANTS } from '../artifacts/artifacts.js';
+} from '@toolproof-core/genesis';
+import { CONSTANTS } from '../lookups/lookups.js';
 import type { StrategyState } from './strategyState.js';
 
-type ToolStepId = string;
-type ToolStepWithId = ToolStep & { id: ToolStepId };
-
-function getToolStepId(toolStep: ToolStep | undefined): ToolStepId | undefined {
-    const maybeId = (toolStep as Partial<ToolStepWithId> | undefined)?.id;
-    return typeof maybeId === 'string' ? maybeId : undefined;
+type ToolStepSlot = 'self' | 'case.when' | 'case.what' | 'cases.when' | 'cases.what';
+
+function toUnthreadedToolStepPath(opts: {
+    stepIndex: number;
+    toolStepSlot: ToolStepSlot;
+    caseIndex?: number;
+}): ToolStepPath {
+    const base = `/steps/${opts.stepIndex}`;
+    switch (opts.toolStepSlot) {
+        case 'self':
+            return `${base}/self` as ToolStepPath;
+        case 'case.when':
+            return `${base}/case/when` as ToolStepPath;
+        case 'case.what':
+            return `${base}/case/what` as ToolStepPath;
+        case 'cases.when':
+            if (typeof opts.caseIndex !== 'number') {
+                throw new Error('Expected caseIndex for cases.when path');
+            }
+            return `${base}/cases/${opts.caseIndex}/when` as ToolStepPath;
+        case 'cases.what':
+            if (typeof opts.caseIndex !== 'number') {
+                throw new Error('Expected caseIndex for cases.what path');
+            }
+            return `${base}/cases/${opts.caseIndex}/what` as ToolStepPath;
+        default: {
+            const _exhaustive: never = opts.toolStepSlot;
+            return _exhaustive;
+        }
+    }
 }
 
 
@@ -25,54 +50,81 @@ export function getIndependentThreads(steps: Step[], strategyState: StrategyStat
         return `steps[${ownerIndex}] stepKind=${(step as any)?.stepKind ?? 'unknown'}`;
     };
 
-    // Map each toolStep.id (including macro-nested tool steps) to owning top-level step index.
-    const toolStepIdToOwner = new Map<ToolStepId, OwnerIndex>();
-    const ownerToToolStepIds = new Map<OwnerIndex, ToolStepId[]>();
-    const toolStepById = new Map<ToolStepId, ToolStepWithId>();
+    // Map each canonical toolStepPath (including macro-nested tool steps) to its owning top-level step index.
+    const toolStepPathToOwner = new Map<ToolStepPath, OwnerIndex>();
+    const toolStepByPath = new Map<ToolStepPath, ToolStep>();
 
-    const addToolStep = (toolStep: ToolStep | undefined, ownerIndex: OwnerIndex) => {
-        const toolStepId = getToolStepId(toolStep);
-        if (!toolStepId || !toolStep) return;
+    const addToolStep = (
+        toolStep: ToolStep | undefined,
+        ownerIndex: OwnerIndex,
+        toolStepPath: 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)}`
+                `Duplicate toolStepPath '${toolStepPath}' found in ${getOwnerLabel(ownerIndex)} and ${getOwnerLabel(existingOwner)}`
             );
         }
 
-        toolStepIdToOwner.set(toolStepId, ownerIndex);
-        toolStepById.set(toolStepId, toolStep as ToolStepWithId);
-        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 as ToolStep, ownerIndex);
+            addToolStep(
+                step as ToolStep,
+                ownerIndex,
+                toUnthreadedToolStepPath({ stepIndex: ownerIndex, toolStepSlot: 'self' }),
+            );
             return;
         }
 
         if (step.stepKind === CONSTANTS.Enums.StepKind.for) {
             const loop = step as ForStep;
-            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 as WhileStep;
-            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 as BranchStep;
-            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;
         }
@@ -93,30 +145,30 @@ export function getIndependentThreads(steps: Step[], strategyState: StrategyStat
     }
 
     // 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] ?? ({} as any);
+        const bucket = strategyState?.[toolStepPath] ?? ({} as any);
 
         for (const inputRoleId of inputBindings) {
             const entry = bucket?.[inputRoleId] as any;
-            if (!entry || entry.strategyStateInputKind !== 'referenceInput') continue;
+            if (!entry || entry.strategyStateInputKind !== 'internalInputPotential') continue;
 
-            const creatorToolStepId = typeof entry?.toolStepPath === 'string'
-                ? entry.toolStepPath as ToolStepId
+            const creatorToolStepPath = typeof entry?.toolStepRoleAddress?.toolStepPath === 'string'
+                ? entry.toolStepRoleAddress.toolStepPath as ToolStepPath
                 : undefined;
-            if (!creatorToolStepId) {
+            if (!creatorToolStepPath) {
                 throw new Error(
-                    `Unresolvable referenceInput in toolStep '${toolStepId}' (${getOwnerLabel(ownerIndex)}): missing toolStepPath for role '${inputRoleId}'`
+                    `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`
+                    `Unresolvable internalInputPotential in toolStep '${toolStepPath}' (${getOwnerLabel(ownerIndex)}): source toolStepPath '${creatorToolStepPath}' not found in strategy steps`
                 );
             }
 

package/src/utils/resolveStrategyStateChain.ts

@@ -0,0 +1,58 @@
+import type {
+    ToolStepRoleAddress,
+    ExternalInputPotential,
+    InputResource,
+    InternalInputPotential,
+    StrategyStateInputEntry,
+    ThreadedStrategyState,
+    ThreadedToolStepRoleAddress,
+    UnthreadedStrategyState,
+    UnthreadedToolStepRoleAddress,
+} from '@toolproof-core/genesis';
+import { getStrategyStateEntry, 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 function resolveStrategyStateChain<TStrategyState extends StrategyState>(
+    strategyState: TStrategyState,
+    start: ToolStepRoleAddressForStrategyState<TStrategyState>,
+    opts?: { maxDepth?: number }
+): ResolveResult {
+    const maxDepth = opts?.maxDepth ?? 50;
+    const visited = new Set<string>();
+    const path: ToolStepRoleAddress[] = [];
+    let current: ToolStepRoleAddressForStrategyState<TStrategyState> = start;
+
+    for (let depth = 0; depth <= maxDepth; depth++) {
+        path.push(current);
+        const visitKey = `${current.toolStepPath}::${current.roleName}`;
+        if (visited.has(visitKey)) {
+            return { status: 'unresolved', reason: 'cycle', path };
+        }
+        visited.add(visitKey);
+
+        const entry = getStrategyStateEntry(strategyState, current) as StrategyStateInputEntry | undefined;
+        if (!entry) return { status: 'unresolved', reason: 'not-found', path };
+
+        if (entry.strategyStateInputKind === 'inputResource') {
+            return { status: 'inputResource', entry, path };
+        }
+        if (entry.strategyStateInputKind === 'externalInputPotential') {
+            return { status: 'externalInputPotential', entry, path };
+        }
+
+        current = (entry as InternalInputPotential).toolStepRoleAddress as ToolStepRoleAddressForStrategyState<TStrategyState>;
+    }
+
+    return { status: 'unresolved', reason: 'depth-exceeded', path };
+}

package/src/utils/roleSpec.ts

@@ -1,11 +1,15 @@
 import type {
     RoleName,
     RoleValue,
-    Strategy,
     Step,
+    StepArrayArray,
     Tool,
     ToolStep,
-} from '@toolproof-core/schema';
+} from '@toolproof-core/genesis';
+
+export type StrategyStepGraph =
+    | { steps: Step[] }
+    | { stepsByThreadIndex: StepArrayArray };
 
 export interface ToolRoleDescriptor extends RoleValue {
     id: RoleName;
@@ -36,7 +40,7 @@ export function toToolRoleDescriptor([roleName, roleValue]: [RoleName, RoleValue
     };
 }
 
-export function extractToolStepsFromStrategy(strategy: Strategy): ToolStep[] {
+export function extractToolStepsFromStrategy(strategy: StrategyStepGraph): ToolStep[] {
     const toolSteps: ToolStep[] = [];
 
     const visitStep = (step: Step) => {

package/src/utils/strategyState.ts

@@ -1,56 +1,128 @@
 import type {
-    CreationContext,
+    ToolStepRoleAddress,
+    ToolStepPath,
+    Resource,
+    InputResource,
+    InternalInputPotential,
+    ExternalInputPotential,
     Strategy,
     StrategyStateInputEntry,
     StrategyStateInputEntryByRoleName,
-} from '@toolproof-core/schema';
+    ThreadedStrategyState,
+    ThreadedToolStepPath,
+    ThreadedToolStepRoleAddress,
+    UnthreadedStrategyState,
+    UnthreadedToolStepPath,
+    UnthreadedToolStepRoleAddress,
+} from '@toolproof-core/genesis';
 
 export type StrategyState = Strategy['strategyState'];
 
-export function getStrategyStateBucket(
-    strategyState: StrategyState,
-    toolStepPath: CreationContext['toolStepPath'],
+type ToolStepPathForStrategyState<TStrategyState extends StrategyState> =
+    TStrategyState extends UnthreadedStrategyState
+        ? UnthreadedToolStepPath
+        : TStrategyState extends ThreadedStrategyState
+            ? ThreadedToolStepPath
+            : ToolStepPath;
+
+type ToolStepRoleAddressForStrategyState<TStrategyState extends StrategyState> =
+    TStrategyState extends UnthreadedStrategyState
+        ? UnthreadedToolStepRoleAddress
+        : TStrategyState extends ThreadedStrategyState
+            ? ThreadedToolStepRoleAddress
+            : ToolStepRoleAddress;
+
+export function getStrategyStateBucket<TStrategyState extends StrategyState>(
+    strategyState: TStrategyState,
+    toolStepPath: ToolStepPathForStrategyState<TStrategyState>,
 ): StrategyStateInputEntryByRoleName | undefined {
-    return strategyState[toolStepPath];
+    return strategyState[toolStepPath] as StrategyStateInputEntryByRoleName | undefined;
 }
 
-export function getStrategyStateEntry(
-    strategyState: StrategyState,
-    context: CreationContext,
+export function getStrategyStateEntry<TStrategyState extends StrategyState>(
+    strategyState: TStrategyState,
+    toolStepRoleAddress: ToolStepRoleAddressForStrategyState<TStrategyState>,
 ): StrategyStateInputEntry | undefined {
-    return getStrategyStateBucket(strategyState, context.toolStepPath)?.[context.roleName];
+    const toolStepPath = toolStepRoleAddress.toolStepPath as ToolStepPathForStrategyState<TStrategyState>;
+    return getStrategyStateBucket(strategyState, toolStepPath)?.[toolStepRoleAddress.roleName];
 }
 
-export function setStrategyStateEntry(
-    strategyState: StrategyState,
-    context: CreationContext,
+export function setStrategyStateEntry<TStrategyState extends StrategyState>(
+    strategyState: TStrategyState,
+    toolStepRoleAddress: ToolStepRoleAddressForStrategyState<TStrategyState>,
     entry: StrategyStateInputEntry,
-): StrategyState {
-    const bucket = getStrategyStateBucket(strategyState, context.toolStepPath) ?? {};
+): TStrategyState {
+    const toolStepPath = toolStepRoleAddress.toolStepPath as ToolStepPathForStrategyState<TStrategyState>;
+    const bucket = getStrategyStateBucket(strategyState, toolStepPath) ?? {};
 
     return {
         ...strategyState,
-        [context.toolStepPath]: {
+        [toolStepPath]: {
             ...bucket,
-            [context.roleName]: entry,
+            [toolStepRoleAddress.roleName]: entry,
         },
-    };
+    } as TStrategyState;
 }
 
-export function clearStrategyStateEntry(
-    strategyState: StrategyState,
-    context: CreationContext,
-): StrategyState {
-    const bucket = getStrategyStateBucket(strategyState, context.toolStepPath);
-    if (!bucket || !(context.roleName in bucket)) {
+export function clearStrategyStateEntry<TStrategyState extends StrategyState>(
+    strategyState: TStrategyState,
+    toolStepRoleAddress: ToolStepRoleAddressForStrategyState<TStrategyState>,
+): TStrategyState {
+    const toolStepPath = toolStepRoleAddress.toolStepPath as ToolStepPathForStrategyState<TStrategyState>;
+    const bucket = getStrategyStateBucket(strategyState, toolStepPath);
+    if (!bucket || !(toolStepRoleAddress.roleName in bucket)) {
         return strategyState;
     }
 
     const nextBucket = { ...bucket };
-    delete nextBucket[context.roleName];
+    delete nextBucket[toolStepRoleAddress.roleName];
 
     return {
         ...strategyState,
-        [context.toolStepPath]: nextBucket,
+        [toolStepPath]: nextBucket,
+    } as TStrategyState;
+}
+
+export function bindInputResource<TStrategyState extends StrategyState>(
+    strategyState: TStrategyState,
+    target: ToolStepRoleAddressForStrategyState<TStrategyState>,
+    resource: Resource,
+): TStrategyState {
+    const inputResource: InputResource = {
+        ...resource,
+        strategyStateInputKind: 'inputResource',
     };
-}
+
+    return setStrategyStateEntry(strategyState, target, inputResource);
+}
+
+export function bindInternalInputPotential<TStrategyState extends StrategyState>(
+    strategyState: TStrategyState,
+    target: ToolStepRoleAddressForStrategyState<TStrategyState>,
+    source: ToolStepRoleAddressForStrategyState<TStrategyState>,
+): TStrategyState {
+    const sourceEntry = getStrategyStateEntry(strategyState, source);
+    if (!sourceEntry) {
+        throw new Error(`resourceEntry not found for source (${source.toolStepPath}, ${source.roleName})`);
+    }
+
+    const internalInputPotential: InternalInputPotential = {
+        strategyStateInputKind: 'internalInputPotential',
+        toolStepRoleAddress: {
+            toolStepPath: source.toolStepPath,
+            roleName: source.roleName,
+        },
+    };
+
+    return setStrategyStateEntry(strategyState, target, internalInputPotential);
+}
+
+export function bindExternalInputPotential<TStrategyState extends StrategyState>(
+    strategyState: TStrategyState,
+    target: ToolStepRoleAddressForStrategyState<TStrategyState>,
+): TStrategyState {
+    const externalInputPotential: ExternalInputPotential = {
+        strategyStateInputKind: 'externalInputPotential',
+    };
+    return setStrategyStateEntry(strategyState, target, externalInputPotential);
+}

package/src/utils_2/threadedStrategyCreation.ts

@@ -0,0 +1,19 @@
+import type { UnthreadedStrategy, ThreadedStrategy, StepArray, StepArrayArray, UnthreadedStrategyState, ThreadedStrategyState } from "@toolproof-core/genesis/types";
+
+
+export const __UnthreadedStrategyToThreadedStrategy = (unthreadedStrategy: UnthreadedStrategy): ThreadedStrategy => {
+    throw new Error('Not implemented yet');
+}
+
+export const __UnthreadedStrategyStateToThreadedStrategyState = (unthreadedStrategyState: UnthreadedStrategyState): ThreadedStrategyState => {
+    throw new Error('Not implemented yet');
+}
+
+export const __StepArrayToStepArrayArray = (stepArray: StepArray): StepArrayArray => {
+    throw new Error('Not implemented yet');
+}
+
+export const __Foo = (unthreadedStrategy: UnthreadedStrategy, draft: any): UnthreadedStrategy => {
+    throw new Error('Not implemented yet');
+}
+