@toolproof-core/lib 1.0.36 → 1.0.37

package/src/utils/parallelizeSteps.ts

@@ -1,239 +0,0 @@
-import type {
-    BranchStep,
-    ForStep,
-    ToolStepPath,
-    ToolStep,
-    Step,
-    WhileStep,
-} from '@toolproof-core/genesis';
-import { CONSTANTS } from '../lookups/lookups.js';
-import type { StrategyState } from './strategyState.js';
-
-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;
-        }
-    }
-}
-
-
-export function getIndependentThreads(steps: Step[], strategyState: StrategyState): Step[][] {
-    type OwnerIndex = number;
-
-    const getOwnerLabel = (ownerIndex: OwnerIndex) => {
-        const step = steps[ownerIndex];
-        return `steps[${ownerIndex}] stepKind=${(step as any)?.stepKind ?? 'unknown'}`;
-    };
-
-    // 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,
-        toolStepPath: ToolStepPath,
-    ) => {
-        if (!toolStep) return;
-
-        const existingOwner = toolStepPathToOwner.get(toolStepPath);
-        if (existingOwner !== undefined) {
-            throw new Error(
-                `Duplicate toolStepPath '${toolStepPath}' found in ${getOwnerLabel(ownerIndex)} and ${getOwnerLabel(existingOwner)}`
-            );
-        }
-
-        toolStepPathToOwner.set(toolStepPath, ownerIndex);
-        toolStepByPath.set(toolStepPath, toolStep);
-    };
-
-    steps.forEach((step, ownerIndex) => {
-        if (step.stepKind === CONSTANTS.Enums.StepKind.tool) {
-            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,
-                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,
-                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 [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;
-        }
-    });
-
-    // Undirected adjacency used for connected components (thread groups).
-    const ownerAdj = new Map<OwnerIndex, Set<OwnerIndex>>();
-    // Directed dependencies used for strict ordering validation: owner -> producers it depends on.
-    const ownerDeps = new Map<OwnerIndex, Set<OwnerIndex>>();
-
-    const ensureOwner = (ownerIndex: OwnerIndex) => {
-        if (!ownerAdj.has(ownerIndex)) ownerAdj.set(ownerIndex, new Set());
-        if (!ownerDeps.has(ownerIndex)) ownerDeps.set(ownerIndex, new Set());
-    };
-
-    for (let i = 0; i < steps.length; i++) {
-        ensureOwner(i);
-    }
-
-    // Discover dependencies from strategyState.
-    for (const [toolStepPath, ownerIndex] of toolStepPathToOwner) {
-        ensureOwner(ownerIndex);
-
-        const toolStep = toolStepByPath.get(toolStepPath);
-        const inputBindings = toolStep?.roleBindingSpec?.inputBindings ?? [];
-        const bucket = strategyState?.[toolStepPath] ?? ({} as any);
-
-        for (const inputRoleId of inputBindings) {
-            const entry = bucket?.[inputRoleId] as any;
-            if (!entry || entry.strategyStateInputKind !== 'internalInputPotential') continue;
-
-            const creatorToolStepPath = typeof entry?.toolStepRoleAddress?.toolStepPath === 'string'
-                ? entry.toolStepRoleAddress.toolStepPath as ToolStepPath
-                : undefined;
-            if (!creatorToolStepPath) {
-                throw new Error(
-                    `Unresolvable internalInputPotential in toolStep '${toolStepPath}' (${getOwnerLabel(ownerIndex)}): missing toolStepRoleAddress.toolStepPath for role '${inputRoleId}'`
-                );
-            }
-
-            const producerOwner = toolStepPathToOwner.get(creatorToolStepPath);
-            if (producerOwner === undefined) {
-                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);
-            ownerAdj.get(producerOwner)!.add(ownerIndex);
-            ownerDeps.get(ownerIndex)!.add(producerOwner);
-        }
-    }
-
-    // Connected components over owners.
-    const visited = new Set<OwnerIndex>();
-    const components: OwnerIndex[][] = [];
-
-    for (let ownerIndex = 0; ownerIndex < steps.length; ownerIndex++) {
-        if (visited.has(ownerIndex)) continue;
-        const component: OwnerIndex[] = [];
-        const queue: OwnerIndex[] = [ownerIndex];
-        visited.add(ownerIndex);
-        while (queue.length > 0) {
-            const node = queue.shift()!;
-            component.push(node);
-            for (const neighbor of ownerAdj.get(node) ?? []) {
-                if (!visited.has(neighbor)) {
-                    visited.add(neighbor);
-                    queue.push(neighbor);
-                }
-            }
-        }
-        components.push(component);
-    }
-
-    // Strict validation: within a thread, the linear order must not contain forward refs.
-    for (const comp of components) {
-        const compSet = new Set(comp);
-        const ownersInOrder = steps.map((_, i) => i).filter((i) => compSet.has(i));
-
-        const position = new Map<OwnerIndex, number>();
-        ownersInOrder.forEach((owner, idx) => position.set(owner, idx));
-
-        for (const consumerOwner of ownersInOrder) {
-            const deps = ownerDeps.get(consumerOwner);
-            if (!deps || deps.size === 0) continue;
-
-            const consumerPos = position.get(consumerOwner)!;
-            for (const producerOwner of deps) {
-                const producerPos = position.get(producerOwner);
-                if (producerPos === undefined) {
-                    throw new Error(
-                        `Internal error: dependency producer ${getOwnerLabel(producerOwner)} missing from computed thread for ${getOwnerLabel(consumerOwner)}`
-                    );
-                }
-                if (producerPos >= consumerPos) {
-                    throw new Error(
-                        `Invalid step order in thread: ${getOwnerLabel(consumerOwner)} depends on ${getOwnerLabel(producerOwner)}, but producer is not scheduled before consumer`
-                    );
-                }
-            }
-        }
-    }
-
-    return components
-        .map((compOwners) => {
-            const ownerSet = new Set(compOwners);
-            return steps.filter((_, i) => ownerSet.has(i));
-        })
-        .filter((group) => group.length > 0);
-}

package/src/utils/resolveStrategyStateChain.ts

@@ -1,58 +0,0 @@
-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,84 +0,0 @@
-import type {
-    RoleName,
-    RoleValue,
-    Step,
-    StepArrayArray,
-    Tool,
-    ToolStep,
-} from '@toolproof-core/genesis';
-
-export type StrategyStepGraph =
-    | { steps: Step[] }
-    | { stepsByThreadIndex: StepArrayArray };
-
-export interface ToolRoleDescriptor extends RoleValue {
-    id: RoleName;
-    name: string;
-}
-
-export function getInputRoleEntries(tool: Tool): Array<[RoleName, RoleValue]> {
-    return Object.entries(tool.roleSpec.inputRoleValueByName) as Array<[RoleName, RoleValue]>;
-}
-
-export function getOutputRoleEntries(tool: Tool): Array<[RoleName, RoleValue]> {
-    return Object.entries(tool.roleSpec.outputRoleValueByName) as Array<[RoleName, RoleValue]>;
-}
-
-export function getInputRoleNames(tool: Tool): RoleName[] {
-    return getInputRoleEntries(tool).map(([roleName]) => roleName);
-}
-
-export function getOutputRoleNames(tool: Tool): RoleName[] {
-    return getOutputRoleEntries(tool).map(([roleName]) => roleName);
-}
-
-export function toToolRoleDescriptor([roleName, roleValue]: [RoleName, RoleValue]): ToolRoleDescriptor {
-    return {
-        id: roleName,
-        name: roleName,
-        ...roleValue,
-    };
-}
-
-export function extractToolStepsFromStrategy(strategy: StrategyStepGraph): ToolStep[] {
-    const toolSteps: ToolStep[] = [];
-
-    const visitStep = (step: Step) => {
-        switch (step.stepKind) {
-            case 'tool': {
-                toolSteps.push(step);
-                return;
-            }
-            case 'branch': {
-                for (const conditional of step.cases) {
-                    toolSteps.push(conditional.when, conditional.what);
-                }
-                return;
-            }
-            case 'while':
-            case 'for': {
-                toolSteps.push(step.case.when, step.case.what);
-                return;
-            }
-            default: {
-                const _exhaustive: never = step;
-                return _exhaustive;
-            }
-        }
-    };
-
-    if ('steps' in strategy) {
-        for (const step of strategy.steps) {
-            visitStep(step);
-        }
-        return toolSteps;
-    }
-
-    for (const threadSteps of strategy.stepsByThreadIndex) {
-        for (const step of threadSteps) {
-            visitStep(step);
-        }
-    }
-
-    return toolSteps;
-}

package/src/utils/strategyState.ts

@@ -1,128 +0,0 @@
-import type {
-    ToolStepRoleAddress,
-    ToolStepPath,
-    Resource,
-    InputResource,
-    InternalInputPotential,
-    ExternalInputPotential,
-    Strategy,
-    StrategyStateInputEntry,
-    StrategyStateInputEntryByRoleName,
-    ThreadedStrategyState,
-    ThreadedToolStepPath,
-    ThreadedToolStepRoleAddress,
-    UnthreadedStrategyState,
-    UnthreadedToolStepPath,
-    UnthreadedToolStepRoleAddress,
-} from '@toolproof-core/genesis';
-
-export type StrategyState = Strategy['strategyState'];
-
-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] as StrategyStateInputEntryByRoleName | undefined;
-}
-
-export function getStrategyStateEntry<TStrategyState extends StrategyState>(
-    strategyState: TStrategyState,
-    toolStepRoleAddress: ToolStepRoleAddressForStrategyState<TStrategyState>,
-): StrategyStateInputEntry | undefined {
-    const toolStepPath = toolStepRoleAddress.toolStepPath as ToolStepPathForStrategyState<TStrategyState>;
-    return getStrategyStateBucket(strategyState, toolStepPath)?.[toolStepRoleAddress.roleName];
-}
-
-export function setStrategyStateEntry<TStrategyState extends StrategyState>(
-    strategyState: TStrategyState,
-    toolStepRoleAddress: ToolStepRoleAddressForStrategyState<TStrategyState>,
-    entry: StrategyStateInputEntry,
-): TStrategyState {
-    const toolStepPath = toolStepRoleAddress.toolStepPath as ToolStepPathForStrategyState<TStrategyState>;
-    const bucket = getStrategyStateBucket(strategyState, toolStepPath) ?? {};
-
-    return {
-        ...strategyState,
-        [toolStepPath]: {
-            ...bucket,
-            [toolStepRoleAddress.roleName]: entry,
-        },
-    } as TStrategyState;
-}
-
-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[toolStepRoleAddress.roleName];
-
-    return {
-        ...strategyState,
-        [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

@@ -1,19 +0,0 @@
-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');
-}
-