@toolproof-npm/shared 0.1.106 → 0.1.108

package/dist/_lib/utils/parallelization.js

@@ -1,4 +1,169 @@
 import { CONSTANTS } from '../../constants.js';
+function normalizeExecutionInputBindingMap(execution, strategyState) {
+    const inputBindingMap = execution.roleBindings?.inputBindingMap ?? {};
+    const outputBindingMap = execution.roleBindings?.outputBindingMap ?? {};
+    const bucket = strategyState?.[execution.identity];
+    if (!bucket) {
+        return execution;
+    }
+    let changed = false;
+    const nextInputBindingMap = { ...inputBindingMap };
+    for (const [roleRef, currentResourceId] of Object.entries(inputBindingMap)) {
+        const entryIdentity = bucket?.[roleRef]?.identity;
+        if (typeof entryIdentity === 'string' && entryIdentity.length > 0 && entryIdentity !== currentResourceId) {
+            nextInputBindingMap[roleRef] = entryIdentity;
+            changed = true;
+        }
+    }
+    if (!changed) {
+        return execution;
+    }
+    return {
+        ...execution,
+        roleBindings: {
+            inputBindingMap: nextInputBindingMap,
+            outputBindingMap,
+        },
+    };
+}
+function normalizeStepRoleBindings(step, strategyState) {
+    if (step.kind === CONSTANTS.STEPS.work) {
+        const work = step;
+        if (!work.execution)
+            return step;
+        const nextExecution = normalizeExecutionInputBindingMap(work.execution, strategyState);
+        if (nextExecution === work.execution)
+            return step;
+        return {
+            ...work,
+            execution: nextExecution,
+        };
+    }
+    if (step.kind === CONSTANTS.STEPS.for) {
+        const loop = step;
+        const whatExecution = loop.case?.what?.execution;
+        const whenExecution = loop.case?.when?.execution;
+        const nextWhatExecution = whatExecution
+            ? normalizeExecutionInputBindingMap(whatExecution, strategyState)
+            : whatExecution;
+        const nextWhenExecution = whenExecution
+            ? normalizeExecutionInputBindingMap(whenExecution, strategyState)
+            : whenExecution;
+        if (nextWhatExecution === whatExecution && nextWhenExecution === whenExecution)
+            return step;
+        return {
+            ...loop,
+            case: {
+                ...loop.case,
+                what: loop.case?.what
+                    ? {
+                        ...loop.case.what,
+                        execution: nextWhatExecution,
+                    }
+                    : loop.case?.what,
+                when: loop.case?.when
+                    ? {
+                        ...loop.case.when,
+                        execution: nextWhenExecution,
+                    }
+                    : loop.case?.when,
+            },
+        };
+    }
+    if (step.kind === CONSTANTS.STEPS.while) {
+        const loop = step;
+        const whatExecution = loop.case?.what?.execution;
+        const whenExecution = loop.case?.when?.execution;
+        const nextWhatExecution = whatExecution
+            ? normalizeExecutionInputBindingMap(whatExecution, strategyState)
+            : whatExecution;
+        const nextWhenExecution = whenExecution
+            ? normalizeExecutionInputBindingMap(whenExecution, strategyState)
+            : whenExecution;
+        if (nextWhatExecution === whatExecution && nextWhenExecution === whenExecution)
+            return step;
+        return {
+            ...loop,
+            case: {
+                ...loop.case,
+                what: loop.case?.what
+                    ? {
+                        ...loop.case.what,
+                        execution: nextWhatExecution,
+                    }
+                    : loop.case?.what,
+                when: loop.case?.when
+                    ? {
+                        ...loop.case.when,
+                        execution: nextWhenExecution,
+                    }
+                    : loop.case?.when,
+            },
+        };
+    }
+    if (step.kind === CONSTANTS.STEPS.branch) {
+        const branch = step;
+        const cases = branch.cases ?? [];
+        let changed = false;
+        const nextCases = cases.map((caseItem) => {
+            const whatExecution = caseItem?.what?.execution;
+            const whenExecution = caseItem?.when?.execution;
+            const nextWhatExecution = whatExecution
+                ? normalizeExecutionInputBindingMap(whatExecution, strategyState)
+                : whatExecution;
+            const nextWhenExecution = whenExecution
+                ? normalizeExecutionInputBindingMap(whenExecution, strategyState)
+                : whenExecution;
+            if (nextWhatExecution !== whatExecution || nextWhenExecution !== whenExecution) {
+                changed = true;
+            }
+            return {
+                ...caseItem,
+                what: caseItem?.what
+                    ? {
+                        ...caseItem.what,
+                        execution: nextWhatExecution,
+                    }
+                    : caseItem?.what,
+                when: caseItem?.when
+                    ? {
+                        ...caseItem.when,
+                        execution: nextWhenExecution,
+                    }
+                    : caseItem?.when,
+            };
+        });
+        if (!changed)
+            return step;
+        return {
+            ...branch,
+            cases: nextCases,
+        };
+    }
+    return step;
+}
+function normalizeStatefulStrategyInputBindingMaps(statefulStrategy) {
+    const steps = statefulStrategy.statelessStrategy?.steps;
+    if (!steps || steps.length === 0)
+        return statefulStrategy;
+    const strategyState = (statefulStrategy.strategyState ?? {});
+    let changed = false;
+    const nextSteps = steps.map((step) => {
+        const nextStep = normalizeStepRoleBindings(step, strategyState);
+        if (nextStep !== step)
+            changed = true;
+        return nextStep;
+    });
+    if (!changed)
+        return statefulStrategy;
+    return {
+        ...statefulStrategy,
+        statelessStrategy: {
+            ...statefulStrategy.statelessStrategy,
+            steps: nextSteps,
+        },
+    };
+}
 function getIndependentThreads(steps, strategyState) {
     const getStepId = (s, i) => s?.execution?.identity || `step-${i}`;
     const stepById = new Map(steps.map((s, i) => [getStepId(s, i), s]));
@@ -57,9 +222,12 @@ export async function statefulStrategyToStrategyRun(statefulStrategy, opts) {
     if (!opts?.getNewIdentity) {
         throw new Error('statefulStrategyToStrategyRun: opts.getNewIdentity is required');
     }
+    // Normalize roleBindings.inputBindingMap to reflect the identities present in strategyState.
+    // This is intentionally a pure transformation (no mutation of the provided statefulStrategy object graph).
+    const normalizedStatefulStrategy = normalizeStatefulStrategyInputBindingMaps(statefulStrategy);
     const strategyRunIdentity = (await opts.getNewIdentity(CONSTANTS.TERMINALS.strategy_run));
-    const steps = statefulStrategy.statelessStrategy?.steps ?? [];
-    const strategyState = (statefulStrategy.strategyState ?? {});
+    const steps = normalizedStatefulStrategy.statelessStrategy?.steps ?? [];
+    const strategyState = (normalizedStatefulStrategy.strategyState ?? {});
     // Algorithm to find what steps can run in parallel
     const threadStepsGroups = getIndependentThreads(steps, strategyState);
     const strategyThreadMap = {};
@@ -69,7 +237,7 @@ export async function statefulStrategyToStrategyRun(statefulStrategy, opts) {
     }
     return {
         identity: strategyRunIdentity,
-        statefulStrategyRef: statefulStrategy.identity,
+        statefulStrategyRef: normalizedStatefulStrategy.identity,
         strategyState: strategyState,
         strategyRunContext: {
             status: opts.status ?? 'running',

package/dist/constants.d.ts

@@ -55,7 +55,7 @@ export declare const CONSTANTS: {
         readonly ROLE_Decison: "ROLE-C4FKVwXipgngzPQc3MDc";
         readonly JOB_Engine: "JOB-Engine";
         readonly JOB_LessThan: "JOB-LessThan";
-        readonly BOOLEAN_false: "RESOURCE-VqJIcOpv9E3zFuGVpN7J";
+        readonly BOOLEAN_false: "RESOURCE-qadnfFGjZsjpqLI0Du1d";
         readonly BOOLEAN_true: "RESOURCE-iZX1cxZ9ImJRzty9Ob4G";
     };
     readonly TESTING: {

package/dist/constants.js

@@ -55,7 +55,7 @@ export const CONSTANTS = {
         ROLE_Decison: 'ROLE-C4FKVwXipgngzPQc3MDc',
         JOB_Engine: 'JOB-Engine',
         JOB_LessThan: 'JOB-LessThan',
-        BOOLEAN_false: 'RESOURCE-VqJIcOpv9E3zFuGVpN7J',
+        BOOLEAN_false: 'RESOURCE-qadnfFGjZsjpqLI0Du1d',
         BOOLEAN_true: 'RESOURCE-iZX1cxZ9ImJRzty9Ob4G',
     },
     TESTING: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-npm/shared",
-  "version": "0.1.106",
+  "version": "0.1.108",
   "description": "Core library utilities for ToolProof",
   "keywords": [
     "toolproof",
@@ -56,7 +56,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@toolproof-npm/schema": "^0.1.72",
+    "@toolproof-npm/schema": "^0.1.73",
     "firebase-admin": "^13.6.0"
   },
   "scripts": {