@toolproof-core/lib 1.0.36 → 1.0.37

package/dist/utils/stepParallelization.js

@@ -0,0 +1,129 @@
+import { CONSTANTS } from '../lookups/lookups.js';
+export function getIndependentThreads(steps, strategyState) {
+    const getOwnerLabel = (ownerIndex) => {
+        const step = steps[ownerIndex];
+        return `steps[${ownerIndex}] stepKind=${step?.stepKind ?? 'unknown'}`;
+    };
+    const toolStepKeyToOwner = new Map();
+    const toolStepByKey = new Map();
+    const addToolStep = (toolStep, ownerIndex) => {
+        if (!toolStep)
+            return;
+        const existingOwner = toolStepKeyToOwner.get(toolStep.toolStepKey);
+        if (existingOwner !== undefined) {
+            throw new Error(`Duplicate toolStepKey '${toolStep.toolStepKey}' found in ${getOwnerLabel(ownerIndex)} and ${getOwnerLabel(existingOwner)}`);
+        }
+        toolStepKeyToOwner.set(toolStep.toolStepKey, ownerIndex);
+        toolStepByKey.set(toolStep.toolStepKey, toolStep);
+    };
+    steps.forEach((step, ownerIndex) => {
+        if (step.stepKind === CONSTANTS.Enums.StepKind.tool) {
+            addToolStep(step, ownerIndex);
+            return;
+        }
+        if (step.stepKind === CONSTANTS.Enums.StepKind.for) {
+            const loop = step;
+            addToolStep(loop.case?.what, ownerIndex);
+            addToolStep(loop.case?.when, ownerIndex);
+            return;
+        }
+        if (step.stepKind === CONSTANTS.Enums.StepKind.while) {
+            const loop = step;
+            addToolStep(loop.case?.what, ownerIndex);
+            addToolStep(loop.case?.when, ownerIndex);
+            return;
+        }
+        if (step.stepKind === CONSTANTS.Enums.StepKind.branch) {
+            const branch = step;
+            for (const stepCase of branch.cases) {
+                addToolStep(stepCase?.what, ownerIndex);
+                addToolStep(stepCase?.when, ownerIndex);
+            }
+        }
+    });
+    const ownerAdj = new Map();
+    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 index = 0; index < steps.length; index++) {
+        ensureOwner(index);
+    }
+    for (const [toolStepKey, ownerIndex] of toolStepKeyToOwner) {
+        ensureOwner(ownerIndex);
+        const toolStep = toolStepByKey.get(toolStepKey);
+        const inputBindings = toolStep?.roleBindingSpec?.inputBindings ?? [];
+        const bucket = strategyState[toolStepKey];
+        for (const inputRoleId of inputBindings) {
+            const entry = bucket?.[inputRoleId];
+            if (!entry || entry.strategyStateInputKind !== 'internalInputPotential')
+                continue;
+            const producerToolStepKey = entry.toolStepRoleAddress?.toolStepKey;
+            if (typeof producerToolStepKey !== 'string') {
+                throw new Error(`Unresolvable internalInputPotential in toolStep '${toolStepKey}' (${getOwnerLabel(ownerIndex)}): missing toolStepRoleAddress.toolStepKey for role '${inputRoleId}'`);
+            }
+            const producerOwner = toolStepKeyToOwner.get(producerToolStepKey);
+            if (producerOwner === undefined) {
+                throw new Error(`Unresolvable internalInputPotential in toolStep '${toolStepKey}' (${getOwnerLabel(ownerIndex)}): source toolStepKey '${producerToolStepKey}' not found in strategy steps`);
+            }
+            ensureOwner(producerOwner);
+            ownerAdj.get(ownerIndex)?.add(producerOwner);
+            ownerAdj.get(producerOwner)?.add(ownerIndex);
+            ownerDeps.get(ownerIndex)?.add(producerOwner);
+        }
+    }
+    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();
+            if (node === undefined)
+                break;
+            component.push(node);
+            for (const neighbor of ownerAdj.get(node) ?? []) {
+                if (visited.has(neighbor))
+                    continue;
+                visited.add(neighbor);
+                queue.push(neighbor);
+            }
+        }
+        components.push(component);
+    }
+    for (const component of components) {
+        const componentOwners = new Set(component);
+        const ownersInOrder = steps.map((_, index) => index).filter((index) => componentOwners.has(index));
+        const position = new Map();
+        ownersInOrder.forEach((owner, index) => position.set(owner, index));
+        for (const consumerOwner of ownersInOrder) {
+            const deps = ownerDeps.get(consumerOwner);
+            if (!deps || deps.size === 0)
+                continue;
+            const consumerPos = position.get(consumerOwner);
+            if (consumerPos === undefined)
+                continue;
+            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((component) => {
+        const ownerSet = new Set(component);
+        return steps.filter((_step, index) => ownerSet.has(index));
+    })
+        .filter((group) => group.length > 0);
+}

package/dist/utils/strategyAssembly.d.ts

@@ -0,0 +1,3 @@
+import type { Strategy } from '@toolproof-core/genesis';
+import type { MutableStrategy } from './mutableStrategyOverlay.js';
+export declare function composeStrategyForExecution<TKey extends string>(mutableStrategy: MutableStrategy<TKey>): Strategy;

package/dist/utils/strategyAssembly.js

@@ -0,0 +1,6 @@
+import { toExecutionMutableStrategy } from './strategyThreading.js';
+import { mutableStrategyToStrategy } from './strategyCanonicalization.js';
+export function composeStrategyForExecution(mutableStrategy) {
+    const executionStrategy = toExecutionMutableStrategy(mutableStrategy);
+    return mutableStrategyToStrategy(executionStrategy);
+}

package/dist/utils/strategyCanonicalization.d.ts

@@ -0,0 +1,4 @@
+import type { Strategy } from '@toolproof-core/genesis';
+import type { MutableStrategy } from './mutableStrategyOverlay.js';
+export declare function strategyToMutableStrategy(strategy: Strategy): MutableStrategy;
+export declare function mutableStrategyToStrategy(mutableStrategy: MutableStrategy): Strategy;

package/dist/utils/strategyCanonicalization.js

@@ -0,0 +1,215 @@
+import { CONSTANTS } from '../lookups/lookups.js';
+import { generateIdentifier } from './identifierGeneration.js';
+function stripMutableCase(stepCase) {
+    const { when, what, ...rest } = stepCase;
+    const { toolStepKey: _whenToolStepKey, ...canonicalWhen } = when;
+    const { toolStepKey: _whatToolStepKey, ...canonicalWhat } = what;
+    return {
+        ...rest,
+        when: canonicalWhen,
+        what: canonicalWhat,
+    };
+}
+function buildExecutionPathMap(strategy) {
+    const executionPathByKey = new Map();
+    const registerStep = (step, pathPrefix) => {
+        switch (step.stepKind) {
+            case CONSTANTS.Enums.StepKind.tool:
+                executionPathByKey.set(step.toolStepKey, `${pathPrefix}/self`);
+                return;
+            case CONSTANTS.Enums.StepKind.branch:
+                step.cases.forEach((stepCase, caseIndex) => {
+                    executionPathByKey.set(stepCase.when.toolStepKey, `${pathPrefix}/cases/${caseIndex}/when`);
+                    executionPathByKey.set(stepCase.what.toolStepKey, `${pathPrefix}/cases/${caseIndex}/what`);
+                });
+                return;
+            case CONSTANTS.Enums.StepKind.while:
+            case CONSTANTS.Enums.StepKind.for:
+                executionPathByKey.set(step.case.when.toolStepKey, `${pathPrefix}/case/when`);
+                executionPathByKey.set(step.case.what.toolStepKey, `${pathPrefix}/case/what`);
+                return;
+            default:
+                throw new Error('Unsupported step kind while projecting strategy.');
+        }
+    };
+    strategy.stepsByThreadIndex.forEach((steps, threadIndex) => {
+        steps.forEach((step, stepIndex) => {
+            registerStep(step, `/threads/${threadIndex}/steps/${stepIndex}`);
+        });
+    });
+    return executionPathByKey;
+}
+function toCanonicalStrategyStateEntry(entry, executionPathByKey) {
+    if (entry.strategyStateInputKind !== 'internalInputPotential') {
+        return entry;
+    }
+    const sourceToolStepPath = executionPathByKey.get(entry.toolStepRoleAddress.toolStepKey);
+    if (!sourceToolStepPath) {
+        throw new Error(`Cannot project strategy state: no execution path found for toolStepKey '${entry.toolStepRoleAddress.toolStepKey}'.`);
+    }
+    return {
+        strategyStateInputKind: 'internalInputPotential',
+        toolStepRoleAddress: {
+            toolStepPath: sourceToolStepPath,
+            roleName: entry.toolStepRoleAddress.roleName,
+        },
+    };
+}
+function toCanonicalStep(step) {
+    switch (step.stepKind) {
+        case CONSTANTS.Enums.StepKind.tool: {
+            const { toolStepKey: _toolStepKey, ...canonicalToolStep } = step;
+            return canonicalToolStep;
+        }
+        case CONSTANTS.Enums.StepKind.branch: {
+            const { macroStepKey: _macroStepKey, cases, ...rest } = step;
+            return {
+                ...rest,
+                cases: cases.map(stripMutableCase),
+            };
+        }
+        case CONSTANTS.Enums.StepKind.while:
+        case CONSTANTS.Enums.StepKind.for: {
+            const { macroStepKey: _macroStepKey, case: stepCase, ...rest } = step;
+            return {
+                ...rest,
+                case: stripMutableCase(stepCase),
+            };
+        }
+        default:
+            throw new Error('Unsupported step kind while projecting steps.');
+    }
+}
+function toMutableStrategyStateEntry(entry, executionKeyByPath) {
+    if (entry.strategyStateInputKind !== 'internalInputPotential') {
+        return entry;
+    }
+    const sourceToolStepKey = executionKeyByPath.get(entry.toolStepRoleAddress.toolStepPath);
+    if (!sourceToolStepKey) {
+        throw new Error(`Cannot deproject strategy state: no mutable key found for toolStepPath '${entry.toolStepRoleAddress.toolStepPath}'.`);
+    }
+    return {
+        strategyStateInputKind: 'internalInputPotential',
+        toolStepRoleAddress: {
+            toolStepKey: sourceToolStepKey,
+            roleName: entry.toolStepRoleAddress.roleName,
+        },
+    };
+}
+function toMutableToolStep(step) {
+    return {
+        ...step,
+        toolStepKey: generateIdentifier('ToolStepKey'),
+    };
+}
+function toMutableCase(stepCase) {
+    const { when, what, ...rest } = stepCase;
+    return {
+        ...rest,
+        when: toMutableToolStep(when),
+        what: toMutableToolStep(what),
+    };
+}
+function toMutableBranchStep(step) {
+    const { cases, ...rest } = step;
+    return {
+        ...rest,
+        macroStepKey: generateIdentifier('BranchStepKey'),
+        cases: cases.map(toMutableCase),
+    };
+}
+function toMutableWhileStep(step) {
+    const { case: stepCase, ...rest } = step;
+    return {
+        ...rest,
+        macroStepKey: generateIdentifier('WhileStepKey'),
+        case: toMutableCase(stepCase),
+    };
+}
+function toMutableForStep(step) {
+    const { case: stepCase, ...rest } = step;
+    return {
+        ...rest,
+        macroStepKey: generateIdentifier('ForStepKey'),
+        case: toMutableCase(stepCase),
+    };
+}
+function toMutableStep(step) {
+    switch (step.stepKind) {
+        case CONSTANTS.Enums.StepKind.tool:
+            return toMutableToolStep(step);
+        case CONSTANTS.Enums.StepKind.branch:
+            return toMutableBranchStep(step);
+        case CONSTANTS.Enums.StepKind.while:
+            return toMutableWhileStep(step);
+        case CONSTANTS.Enums.StepKind.for:
+            return toMutableForStep(step);
+        default:
+            throw new Error('Unsupported step kind while deprojecting steps.');
+    }
+}
+function buildExecutionKeyMap(strategy) {
+    const executionPathByKey = buildExecutionPathMap(strategy);
+    const executionKeyByPath = new Map();
+    for (const [toolStepKey, toolStepPath] of executionPathByKey.entries()) {
+        executionKeyByPath.set(toolStepPath, toolStepKey);
+    }
+    return executionKeyByPath;
+}
+export function strategyToMutableStrategy(strategy) {
+    const stepsByThreadIndex = strategy.stepsByThreadIndex.map((steps) => steps.map(toMutableStep));
+    const seededMutableStrategy = {
+        ...strategy,
+        stepsByThreadIndex,
+        strategyState: {},
+    };
+    const executionKeyByPath = buildExecutionKeyMap(seededMutableStrategy);
+    const strategyState = {};
+    for (const [toolStepPath, inputEntryByRoleName] of Object.entries(strategy.strategyState)) {
+        const toolStepKey = executionKeyByPath.get(toolStepPath);
+        if (!toolStepKey) {
+            throw new Error(`Cannot deproject strategy state: no mutable key found for toolStepPath '${toolStepPath}'.`);
+        }
+        strategyState[toolStepKey] = Object.fromEntries(Object.entries(inputEntryByRoleName).map(([roleName, entry]) => {
+            if (entry === undefined) {
+                throw new Error(`Cannot deproject strategy state: role '${roleName}' on toolStepPath '${toolStepPath}' is explicitly undefined.`);
+            }
+            return [
+                roleName,
+                toMutableStrategyStateEntry(entry, executionKeyByPath),
+            ];
+        }));
+    }
+    return {
+        ...strategy,
+        stepsByThreadIndex,
+        strategyState,
+    };
+}
+export function mutableStrategyToStrategy(mutableStrategy) {
+    const executionPathByKey = buildExecutionPathMap(mutableStrategy);
+    const strategyState = {};
+    for (const [toolStepKey, inputEntryByRoleName] of Object.entries(mutableStrategy.strategyState)) {
+        if (!inputEntryByRoleName) {
+            continue;
+        }
+        const toolStepPath = executionPathByKey.get(toolStepKey);
+        if (!toolStepPath) {
+            throw new Error(`Cannot project strategy state: no execution path found for toolStepKey '${toolStepKey}'.`);
+        }
+        strategyState[toolStepPath] = Object.fromEntries(Object.entries(inputEntryByRoleName).map(([roleName, entry]) => {
+            if (entry === undefined) {
+                throw new Error(`Cannot project strategy state: role '${roleName}' on toolStepKey '${toolStepKey}' is explicitly undefined.`);
+            }
+            return [
+                roleName,
+                toCanonicalStrategyStateEntry(entry, executionPathByKey),
+            ];
+        }));
+    }
+    return {
+        ...mutableStrategy,
+        stepsByThreadIndex: mutableStrategy.stepsByThreadIndex.map((steps) => steps.map(toCanonicalStep)),
+        strategyState,
+    };
+}

package/dist/utils/strategyExtraction.d.ts

@@ -0,0 +1,17 @@
+import type { RoleName, RoleSpec, ToolHandle, Tool, ResourceTypeHandle, RoleValue } from '@toolproof-core/genesis';
+import type { MutableStrategy, MutableToolStep } from './mutableStrategyOverlay.js';
+export type RoleSpecEntry = [RoleName, RoleValue];
+type RoleSpecDirectionKeys = keyof Pick<RoleSpec, 'inputRoleValueByName' | 'outputRoleValueByName'>;
+export type RoleSpecByDirection = {
+    [K in RoleSpecDirectionKeys]: Map<RoleName, RoleValue>;
+};
+export declare function getInputRoleSpecEntriesFromTool(tool: Tool): RoleSpecEntry[];
+export declare function getOutputRoleSpecEntriesFromTool(tool: Tool): RoleSpecEntry[];
+export declare function getInputRoleNamesFromTool(tool: Tool): RoleName[];
+export declare function getOutputRoleNamesFromTool(tool: Tool): RoleName[];
+export declare function extractResourceTypeHandleFromRoleValue(roleValue: RoleValue): ResourceTypeHandle | null;
+export declare function extractToolStepsFromStrategy(strategy: MutableStrategy): MutableToolStep[];
+export declare function extractToolsFromStrategy(strategy: MutableStrategy, toolMap: Map<ToolHandle, Tool>): Tool[];
+export declare function extractRoleSpecByDirectionByToolHandleFromStrategy(strategy: MutableStrategy, toolMap: Map<ToolHandle, Tool>): Map<ToolHandle, RoleSpecByDirection>;
+export declare function extractSingleBranchableOutputResourceTypeHandle(tool: Tool): ResourceTypeHandle | null;
+export {};

package/dist/utils/strategyExtraction.js

@@ -0,0 +1,88 @@
+import { CONSTANTS } from '../lookups/lookups.js';
+export function getInputRoleSpecEntriesFromTool(tool) {
+    return Object.entries(tool.roleSpec.inputRoleValueByName);
+}
+export function getOutputRoleSpecEntriesFromTool(tool) {
+    return Object.entries(tool.roleSpec.outputRoleValueByName);
+}
+export function getInputRoleNamesFromTool(tool) {
+    return getInputRoleSpecEntriesFromTool(tool).map(([roleName]) => roleName);
+}
+export function getOutputRoleNamesFromTool(tool) {
+    return getOutputRoleSpecEntriesFromTool(tool).map(([roleName]) => roleName);
+}
+export function extractResourceTypeHandleFromRoleValue(roleValue) {
+    const typeRef = roleValue.typeRef;
+    if ('resourceTypeHandle' in typeRef) {
+        return typeRef.resourceTypeHandle;
+    }
+    return null;
+}
+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;
+            }
+        }
+    };
+    for (const threadSteps of strategy.stepsByThreadIndex) {
+        for (const step of threadSteps) {
+            visitStep(step);
+        }
+    }
+    return toolSteps;
+}
+export function extractToolsFromStrategy(strategy, toolMap) {
+    const toolSteps = extractToolStepsFromStrategy(strategy);
+    const toolHandles = new Set();
+    const tools = [];
+    for (const toolStep of toolSteps) {
+        toolHandles.add(toolStep.toolHandle);
+    }
+    for (const toolHandle of toolHandles) {
+        const tool = toolMap.get(toolHandle);
+        if (!tool) {
+            throw new Error(`Tool with handle '${toolHandle}' not found in toolMap.`);
+        }
+        tools.push(tool);
+    }
+    return tools;
+}
+function extractRoleSpecByDirectionFromTool(tool) {
+    return {
+        inputRoleValueByName: new Map(getInputRoleSpecEntriesFromTool(tool)),
+        outputRoleValueByName: new Map(getOutputRoleSpecEntriesFromTool(tool)),
+    };
+}
+export function extractRoleSpecByDirectionByToolHandleFromStrategy(strategy, toolMap) {
+    const roleSpecByDirectionByToolHandle = new Map();
+    for (const tool of extractToolsFromStrategy(strategy, toolMap)) {
+        roleSpecByDirectionByToolHandle.set(tool.handle, extractRoleSpecByDirectionFromTool(tool));
+    }
+    return roleSpecByDirectionByToolHandle;
+}
+export function extractSingleBranchableOutputResourceTypeHandle(tool) {
+    const outputRoleSpecEntries = getOutputRoleSpecEntriesFromTool(tool).filter(([roleName]) => roleName !== CONSTANTS.Cosmos.ErrorOutputRoleName);
+    if (!outputRoleSpecEntries[0] || outputRoleSpecEntries.length !== 1) {
+        throw new Error(`Tool ${tool.handle} must have exactly one branchable output resource type to be branchable/loopable`);
+    }
+    return extractResourceTypeHandleFromRoleValue(outputRoleSpecEntries[0][1]);
+}

package/dist/utils/strategyStateResolution.d.ts

@@ -0,0 +1,17 @@
+import type { MutableInputResource, MutableExternalInputPotential, MutableStrategyState, MutableToolStepKey, MutableToolStepRoleAddress } from './mutableStrategyOverlay.js';
+export type ResolveResult<TKey extends string = MutableToolStepKey> = {
+    status: 'inputResource';
+    entry: MutableInputResource;
+    path: MutableToolStepRoleAddress<TKey>[];
+} | {
+    status: 'externalInputPotential';
+    entry: MutableExternalInputPotential;
+    path: MutableToolStepRoleAddress<TKey>[];
+} | {
+    status: 'unresolved';
+    reason: 'not-found' | 'cycle' | 'depth-exceeded';
+    path: MutableToolStepRoleAddress<TKey>[];
+};
+export declare function resolveStrategyStateChain<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, start: MutableToolStepRoleAddress<TKey>, opts?: {
+    maxDepth?: number;
+}): ResolveResult<TKey>;

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

@@ -1,4 +1,4 @@
-import { getStrategyStateEntry } from './strategyState.js';
+import { getStrategyStateInputEntry } from './mutableStrategyOverlay.js';
 export function resolveStrategyStateChain(strategyState, start, opts) {
     const maxDepth = opts?.maxDepth ?? 50;
     const visited = new Set();
@@ -6,14 +6,15 @@ export function resolveStrategyStateChain(strategyState, start, opts) {
     let current = start;
     for (let depth = 0; depth <= maxDepth; depth++) {
         path.push(current);
-        const visitKey = `${current.toolStepPath}::${current.roleName}`;
+        const visitKey = `${current.toolStepKey}::${current.roleName}`;
         if (visited.has(visitKey)) {
             return { status: 'unresolved', reason: 'cycle', path };
         }
         visited.add(visitKey);
-        const entry = getStrategyStateEntry(strategyState, current);
-        if (!entry)
+        const entry = getStrategyStateInputEntry(strategyState, current);
+        if (!entry) {
             return { status: 'unresolved', reason: 'not-found', path };
+        }
         if (entry.strategyStateInputKind === 'inputResource') {
             return { status: 'inputResource', entry, path };
         }

package/dist/utils/strategyThreading.d.ts

@@ -0,0 +1,2 @@
+import type { MutableStrategy, MutableStep, MutableStrategyState, MutableToolStepKey } from './mutableStrategyOverlay.js';
+export declare function toExecutionMutableStrategy<TKey extends string = MutableToolStepKey, TStep extends MutableStep<TKey> = MutableStep<TKey>, TState extends MutableStrategyState<TKey> = MutableStrategyState<TKey>>(mutableStrategy: MutableStrategy<TKey, TStep, TState>): MutableStrategy<TKey, TStep, TState>;

package/dist/utils/strategyThreading.js

@@ -0,0 +1,10 @@
+import { getIndependentThreads } from './stepParallelization.js';
+import { getAuthoringSteps as getAuthoringThreadSteps } from './mutableStrategyOverlay.js';
+export function toExecutionMutableStrategy(mutableStrategy) {
+    const authoringSteps = getAuthoringThreadSteps(mutableStrategy);
+    const stepsByThreadIndex = getIndependentThreads(authoringSteps, mutableStrategy.strategyState);
+    return {
+        ...mutableStrategy,
+        stepsByThreadIndex: stepsByThreadIndex,
+    };
+}

package/dist/utils/toolStepPaths.d.ts

@@ -0,0 +1,2 @@
+import type { ToolStepPath, ToolStepPathSpec } from '@toolproof-core/genesis';
+export declare function toToolStepPath(spec: ToolStepPathSpec): ToolStepPath;

package/dist/utils/toolStepPaths.js

@@ -0,0 +1,21 @@
+function getToolStepPathSuffix(spec) {
+    if (spec.toolStepPathSlot === 'self') {
+        return '/self';
+    }
+    if (spec.toolStepPathSlot === 'cases/when' || spec.toolStepPathSlot === 'cases/what') {
+        if (typeof spec.caseIndex !== 'number') {
+            throw new Error('Expected caseIndex for branch tool-step path construction');
+        }
+        return `/cases/${spec.caseIndex}/${spec.toolStepPathSlot === 'cases/when' ? 'when' : 'what'}`;
+    }
+    if (spec.toolStepPathSlot === 'case/when') {
+        return '/case/when';
+    }
+    if (spec.toolStepPathSlot === 'case/what') {
+        return '/case/what';
+    }
+    throw new Error(`Unsupported tool-step path slot '${String(spec.toolStepPathSlot)}'`);
+}
+export function toToolStepPath(spec) {
+    return `/threads/${spec.threadIndex}/steps/${spec.stepIndex}${getToolStepPathSuffix(spec)}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-core/lib",
-  "version": "1.0.36",
+  "version": "1.0.37",
   "description": "",
   "type": "module",
   "keywords": [],
@@ -15,29 +15,49 @@
       "types": "./dist/types/types.d.ts",
       "import": "./dist/types/types.js"
     },
-    "./extract-data": {
-      "types": "./dist/utils/extractData.d.ts",
-      "import": "./dist/utils/extractData.js"
+    "./identifier-generation": {
+      "types": "./dist/utils/identifierGeneration.d.ts",
+      "import": "./dist/utils/identifierGeneration.js"
     },
-    "./create-resource": {
-      "types": "./dist/utils/creation/resourceCreation.d.ts",
-      "import": "./dist/utils/creation/resourceCreation.js"
+    "./strategy-assembly": {
+      "types": "./dist/utils/strategyAssembly.d.ts",
+      "import": "./dist/utils/strategyAssembly.js"
     },
-    "./create-step": {
-      "types": "./dist/integrations/firebase/createStep.d.ts",
-      "import": "./dist/integrations/firebase/createStep.js"
+    "./cosmos-data-extraction": {
+      "types": "./dist/utils/cosmosDataExtraction.d.ts",
+      "import": "./dist/utils/cosmosDataExtraction.js"
     },
-    "./create-threaded-strategy": {
-      "types": "./dist/integrations/firebase/createThreadedStrategy.d.ts",
-      "import": "./dist/integrations/firebase/createThreadedStrategy.js"
+    "./strategy-extraction": {
+      "types": "./dist/utils/strategyExtraction.d.ts",
+      "import": "./dist/utils/strategyExtraction.js"
     },
-    "./resolve-strategy-state-chain": {
-      "types": "./dist/utils/resolveStrategyStateChain.d.ts",
-      "import": "./dist/utils/resolveStrategyStateChain.js"
+    "./resource-creation": {
+      "types": "./dist/utils/resourceCreation.d.ts",
+      "import": "./dist/utils/resourceCreation.js"
     },
-    "./strategy-state": {
-      "types": "./dist/utils/strategyState.d.ts",
-      "import": "./dist/utils/strategyState.js"
+    "./step-creation": {
+      "types": "./dist/utils/stepCreation.d.ts",
+      "import": "./dist/utils/stepCreation.js"
+    },
+    "./tool-step-paths": {
+      "types": "./dist/utils/toolStepPaths.d.ts",
+      "import": "./dist/utils/toolStepPaths.js"
+    },
+    "./strategy-state-resolution": {
+      "types": "./dist/utils/strategyStateResolution.d.ts",
+      "import": "./dist/utils/strategyStateResolution.js"
+    },
+    "./mutable-strategy-overlay": {
+      "types": "./dist/utils/mutableStrategyOverlay.d.ts",
+      "import": "./dist/utils/mutableStrategyOverlay.js"
+    },
+    "./strategy-threading": {
+      "types": "./dist/utils/strategyThreading.d.ts",
+      "import": "./dist/utils/strategyThreading.js"
+    },
+    "./strategy-canonicalization": {
+      "types": "./dist/utils/strategyCanonicalization.d.ts",
+      "import": "./dist/utils/strategyCanonicalization.js"
     },
     "./firebase-admin-init": {
       "types": "./dist/integrations/firebase/firebaseAdminInit.d.ts",
@@ -52,8 +72,8 @@
     "@types/node": "^22.0.0"
   },
   "dependencies": {
-    "firebase-admin": "^13.7.0",
-    "@toolproof-core/genesis": "1.0.56"
+    "@toolproof-core/genesis": "^1.0.58",
+    "firebase-admin": "^13.7.0"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",