@toolproof-core/lib 1.0.36 → 1.0.37

package/dist/integrations/firebase/createStep.d.ts

@@ -1,10 +0,0 @@
-import type { BranchStep, ForStep, Tool, ToolStep, WhileStep } from '@toolproof-core/genesis';
-import { CONSTANTS } from '../../lookups/lookups.js';
-export declare function createToolStepFromTool(tool: Tool): ToolStep;
-export declare function createLoopStepFromToolPair(whatTool: Tool, whenTool: Tool, stepKind: typeof CONSTANTS.Enums.StepKind.for | typeof CONSTANTS.Enums.StepKind.while): ForStep | WhileStep;
-export declare function createBranchStepFromToolPairs(cases: Array<{
-    whatTool: Tool;
-    whenTool: Tool;
-}>): BranchStep;
-export declare function cloneForStep(forStep: ForStep): ForStep;
-export declare function cloneWhileStep(whileStep: WhileStep): WhileStep;

package/dist/integrations/firebase/createStep.js

@@ -1,17 +0,0 @@
-import { CONSTANTS } from '../../lookups/lookups.js';
-import { buildBranchStepFromToolPairs, buildToolStepFromTool, buildLoopStepFromToolPair, cloneForStep as cloneForStepPure, cloneWhileStep as cloneWhileStepPure, } from '../../utils/creation/stepCreation.js';
-export function createToolStepFromTool(tool) {
-    return buildToolStepFromTool(tool);
-}
-export function createLoopStepFromToolPair(whatTool, whenTool, stepKind) {
-    return buildLoopStepFromToolPair(whatTool, whenTool, stepKind);
-}
-export function createBranchStepFromToolPairs(cases) {
-    return buildBranchStepFromToolPairs(cases);
-}
-export function cloneForStep(forStep) {
-    return cloneForStepPure(forStep);
-}
-export function cloneWhileStep(whileStep) {
-    return cloneWhileStepPure(whileStep);
-}

package/dist/integrations/firebase/createThreadedStrategy.d.ts

@@ -1,2 +0,0 @@
-import { type ThreadableStrategy, type ThreadedStrategyLike } from '../../utils/creation/threadedStrategyCreation.js';
-export declare function createThreadedStrategy<TStrategyState>(strategy: ThreadableStrategy<TStrategyState>): ThreadedStrategyLike<TStrategyState>;

package/dist/integrations/firebase/createThreadedStrategy.js

@@ -1,8 +0,0 @@
-import { CONSTANTS } from '../../lookups/lookups.js';
-import { buildThreadedStrategy, getThreadedStrategyStepGroups, } from '../../utils/creation/threadedStrategyCreation.js';
-import { getNewId } from './firebaseAdminHelpers.js';
-export function createThreadedStrategy(strategy) {
-    const threadStepGroups = getThreadedStrategyStepGroups(strategy);
-    const strategyHandle = getNewId(CONSTANTS.Names.StrategyHandle);
-    return buildThreadedStrategy(threadStepGroups, strategyHandle, strategy);
-}

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

@@ -1,21 +0,0 @@
-import type { ToolStepRoleAddress, ExternalInputPotential, InternalInputPotential, ResourceId, Resource, ResourcePointer, ResourceTypeHandle, StrategyProvenance, Provenance, StrategyTraceHandle } from '@toolproof-core/genesis';
-type RuntimeProvenance = Extract<Provenance, {
-    provenanceKind: 'runtime';
-}>;
-export interface OutputPotential {
-    id: ResourceId;
-    resourceTypeHandle: ResourceTypeHandle;
-    toolStepRoleAddress?: ToolStepRoleAddress;
-    strategyTraceHandle?: StrategyTraceHandle;
-    provenanceKind?: Provenance['provenanceKind'];
-}
-export declare function createExternalInputPotential(): ExternalInputPotential;
-export declare function createInternalInputPotential(toolStepRoleAddress: ToolStepRoleAddress): InternalInputPotential;
-export declare function createStrategyProvenance(strategyTraceHandle: StrategyTraceHandle, toolStepRoleAddress: ToolStepRoleAddress): StrategyProvenance;
-export declare function createRuntimeProvenance(): RuntimeProvenance;
-export declare function createResourcePointer(id: ResourceId, resourceTypeHandle: ResourceTypeHandle, provenance: Provenance): ResourcePointer;
-export declare function createResource(resourcePointer: ResourcePointer, projection: unknown): Resource;
-export declare function createMaterializedFromOutputPotential(outputPotential: OutputPotential, projection: unknown): Resource;
-export declare function createMaterializedFromPotential(outputPotential: OutputPotential, projection: unknown): Resource;
-export declare function createOutputPotential(id: ResourceId, resourceTypeHandle: ResourceTypeHandle, toolStepRoleAddress?: ToolStepRoleAddress, strategyTraceHandle?: StrategyTraceHandle, provenanceKind?: Provenance['provenanceKind']): OutputPotential;
-export {};

package/dist/utils/creation/resourceCreation.js

@@ -1,67 +0,0 @@
-export function createExternalInputPotential() {
-    return {
-        strategyStateInputKind: 'externalInputPotential',
-    };
-}
-export function createInternalInputPotential(toolStepRoleAddress) {
-    return {
-        strategyStateInputKind: 'internalInputPotential',
-        toolStepRoleAddress,
-    };
-}
-export function createStrategyProvenance(strategyTraceHandle, toolStepRoleAddress) {
-    return {
-        provenanceKind: 'strategy',
-        strategyTraceHandle,
-        toolStepRoleAddress,
-    };
-}
-export function createRuntimeProvenance() {
-    return {
-        provenanceKind: 'runtime',
-    };
-}
-export function createResourcePointer(id, resourceTypeHandle, provenance) {
-    return {
-        id,
-        resourceTypeHandle,
-        provenance,
-    };
-}
-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,
-        resourceTypeHandle,
-        ...(toolStepRoleAddress ? { toolStepRoleAddress } : {}),
-        ...(strategyTraceHandle ? { strategyTraceHandle } : {}),
-        ...(provenanceKind ? { provenanceKind } : {}),
-    };
-}
-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,10 +0,0 @@
-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;
-}>): BranchStep;
-export declare function cloneForStep(forStep: ForStep): ForStep;
-export declare function cloneWhileStep(whileStep: WhileStep): WhileStep;

package/dist/utils/creation/stepCreation.js

@@ -1,64 +0,0 @@
-import { CONSTANTS } from '../../lookups/lookups.js';
-import { getInputRoleNames, getOutputRoleNames } from '../roleSpec.js';
-function assertNonEmpty(arr, msg) {
-    if (arr.length === 0) {
-        throw new Error(msg);
-    }
-}
-function getRoleBindingSpec(tool) {
-    return {
-        inputBindings: getInputRoleNames(tool),
-        outputBindings: getOutputRoleNames(tool),
-    };
-}
-export function buildToolStepFromTool(tool) {
-    return {
-        stepKind: CONSTANTS.Enums.StepKind.tool,
-        toolHandle: tool.handle,
-        roleBindingSpec: getRoleBindingSpec(tool),
-    };
-}
-export function buildLoopStepFromToolPair(whatTool, whenTool, stepKind) {
-    const what = buildToolStepFromTool(whatTool);
-    const when = buildToolStepFromTool(whenTool);
-    if (stepKind === CONSTANTS.Enums.StepKind.for) {
-        return {
-            stepKind: CONSTANTS.Enums.StepKind.for,
-            case: { what, when },
-        };
-    }
-    return {
-        stepKind: CONSTANTS.Enums.StepKind.while,
-        case: { what, when },
-    };
-}
-export function buildBranchStepFromToolPairs(cases) {
-    const resolved = cases.map(({ whatTool, whenTool }, index) => {
-        const what = buildToolStepFromTool(whatTool);
-        const when = buildToolStepFromTool(whenTool);
-        return { what, when };
-    });
-    assertNonEmpty(resolved, 'buildBranchStepFromToolPairs requires at least one case');
-    return {
-        stepKind: CONSTANTS.Enums.StepKind.branch,
-        cases: resolved,
-    };
-}
-export function cloneForStep(forStep) {
-    return {
-        stepKind: CONSTANTS.Enums.StepKind.for,
-        case: {
-            what: { ...forStep.case.what },
-            when: { ...forStep.case.when },
-        },
-    };
-}
-export function cloneWhileStep(whileStep) {
-    return {
-        stepKind: CONSTANTS.Enums.StepKind.while,
-        case: {
-            what: { ...whileStep.case.what },
-            when: { ...whileStep.case.when },
-        },
-    };
-}

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

@@ -1,18 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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,12 +0,0 @@
-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<ResourceTypeHandle, TResource[]>>, resourceTypeHandle: ResourceTypeHandle): Map<TKey, TValue>;

package/dist/utils/extractData.js

@@ -1,78 +0,0 @@
-import { extractToolStepsFromStrategy, getInputRoleEntries, getOutputRoleEntries, toToolRoleDescriptor, } from './roleSpec.js';
-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.toolHandle);
-    }
-    return Array.from(ids);
-}
-export function extractToolStepsFromUnthreadedStrategy(unthreadedStrategy) {
-    return extractToolStepsFromStrategy(unthreadedStrategy);
-}
-export function extractRoleMapFromUnthreadedStrategy(unthreadedStrategy, toolMap) {
-    const roleMap = new Map();
-    const toolHandles = extractToolHandlesFromUnthreadedStrategy(unthreadedStrategy);
-    for (const toolHandle of toolHandles) {
-        const tool = toolMap.get(toolHandle);
-        if (!tool)
-            continue;
-        for (const entry of getInputRoleEntries(tool)) {
-            roleMap.set(entry[0], toToolRoleDescriptor(entry));
-        }
-        for (const entry of getOutputRoleEntries(tool)) {
-            roleMap.set(entry[0], toToolRoleDescriptor(entry));
-        }
-    }
-    return roleMap;
-}
-export function extractSingleNonErrorOutputTypeId(tool) {
-    const outputEntries = getOutputRoleEntries(tool).filter(([roleName]) => roleName !== ERROR_OUTPUT_ROLE_NAME);
-    if (!outputEntries || !outputEntries[0] || outputEntries.length !== 1) {
-        throw new Error(`Tool ${tool.handle} must have exactly one non-error output role to be branchable/loopable`);
-    } // ATTENTION_PUREIFY
-    return extractResourceTypeHandleFromRoleValue(toToolRoleDescriptor(outputEntries[0]));
-}
-export function extractResourceMapForType(resourcesByType, resourceTypeHandle) {
-    const resources = resourcesByType[resourceTypeHandle] ?? [];
-    const map = new Map();
-    for (const resource of resources) {
-        map.set(resource.id, resource);
-    }
-    return map;
-}
-// Only use this for resource types whose nuclei are entity-like objects with their own intrinsic id.
-export function extractIdKeyedValueMapForType(resourcesByType, resourceTypeHandle) {
-    const resourceMap = extractResourceMapForType(resourcesByType, resourceTypeHandle);
-    const out = new Map();
-    for (const resource of resourceMap.values()) {
-        const data = resource.projection;
-        if (data === null || data === undefined) {
-            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 '${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 '${resourceTypeHandle}' to have projection.id`);
-        }
-        if (typeof maybeId !== 'string' &&
-            typeof maybeId !== 'number' &&
-            typeof maybeId !== '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);
-        out.set(key, value);
-    }
-    return out;
-}

package/dist/utils/parallelizeSteps.d.ts

@@ -1,3 +0,0 @@
-import type { Step } from '@toolproof-core/genesis';
-import type { StrategyState } from './strategyState.js';
-export declare function getIndependentThreads(steps: Step[], strategyState: StrategyState): Step[][];

package/dist/utils/parallelizeSteps.js

@@ -1,159 +0,0 @@
-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 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 = 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, ownerIndex, toUnthreadedToolStepPath({ stepIndex: ownerIndex, toolStepSlot: 'self' }));
-            return;
-        }
-        if (step.stepKind === CONSTANTS.Enums.StepKind.for) {
-            const loop = step;
-            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, 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 [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();
-    // Directed dependencies used for strict ordering validation: owner -> producers it depends on.
-    const ownerDeps = new Map();
-    const ensureOwner = (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] ?? {};
-        for (const inputRoleId of inputBindings) {
-            const entry = bucket?.[inputRoleId];
-            if (!entry || entry.strategyStateInputKind !== 'internalInputPotential')
-                continue;
-            const creatorToolStepPath = typeof entry?.toolStepRoleAddress?.toolStepPath === 'string'
-                ? entry.toolStepRoleAddress.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();
-    const components = [];
-    for (let ownerIndex = 0; ownerIndex < steps.length; ownerIndex++) {
-        if (visited.has(ownerIndex))
-            continue;
-        const component = [];
-        const queue = [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();
-        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/dist/utils/resolveStrategyStateChain.d.ts

@@ -1,20 +0,0 @@
-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/roleSpec.d.ts

@@ -1,16 +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 declare function getInputRoleEntries(tool: Tool): Array<[RoleName, RoleValue]>;
-export declare function getOutputRoleEntries(tool: Tool): Array<[RoleName, RoleValue]>;
-export declare function getInputRoleNames(tool: Tool): RoleName[];
-export declare function getOutputRoleNames(tool: Tool): RoleName[];
-export declare function toToolRoleDescriptor([roleName, roleValue]: [RoleName, RoleValue]): ToolRoleDescriptor;
-export declare function extractToolStepsFromStrategy(strategy: StrategyStepGraph): ToolStep[];

package/dist/utils/roleSpec.js

@@ -1,57 +0,0 @@
-export function getInputRoleEntries(tool) {
-    return Object.entries(tool.roleSpec.inputRoleValueByName);
-}
-export function getOutputRoleEntries(tool) {
-    return Object.entries(tool.roleSpec.outputRoleValueByName);
-}
-export function getInputRoleNames(tool) {
-    return getInputRoleEntries(tool).map(([roleName]) => roleName);
-}
-export function getOutputRoleNames(tool) {
-    return getOutputRoleEntries(tool).map(([roleName]) => roleName);
-}
-export function toToolRoleDescriptor([roleName, roleValue]) {
-    return {
-        id: roleName,
-        name: roleName,
-        ...roleValue,
-    };
-}
-export function extractToolStepsFromStrategy(strategy) {
-    const toolSteps = [];
-    const visitStep = (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 = 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/dist/utils/strategyState.d.ts

@@ -1,12 +0,0 @@
-import type { ToolStepRoleAddress, ToolStepPath, Resource, 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 declare function getStrategyStateBucket<TStrategyState extends StrategyState>(strategyState: TStrategyState, toolStepPath: ToolStepPathForStrategyState<TStrategyState>): StrategyStateInputEntryByRoleName | undefined;
-export declare function getStrategyStateEntry<TStrategyState extends StrategyState>(strategyState: TStrategyState, toolStepRoleAddress: ToolStepRoleAddressForStrategyState<TStrategyState>): StrategyStateInputEntry | undefined;
-export declare function setStrategyStateEntry<TStrategyState extends StrategyState>(strategyState: TStrategyState, toolStepRoleAddress: ToolStepRoleAddressForStrategyState<TStrategyState>, entry: StrategyStateInputEntry): TStrategyState;
-export declare function clearStrategyStateEntry<TStrategyState extends StrategyState>(strategyState: TStrategyState, toolStepRoleAddress: ToolStepRoleAddressForStrategyState<TStrategyState>): TStrategyState;
-export declare function bindInputResource<TStrategyState extends StrategyState>(strategyState: TStrategyState, target: ToolStepRoleAddressForStrategyState<TStrategyState>, resource: Resource): TStrategyState;
-export declare function bindInternalInputPotential<TStrategyState extends StrategyState>(strategyState: TStrategyState, target: ToolStepRoleAddressForStrategyState<TStrategyState>, source: ToolStepRoleAddressForStrategyState<TStrategyState>): TStrategyState;
-export declare function bindExternalInputPotential<TStrategyState extends StrategyState>(strategyState: TStrategyState, target: ToolStepRoleAddressForStrategyState<TStrategyState>): TStrategyState;
-export {};