@toolproof-npm/shared 0.1.110 → 0.1.111

package/dist/_lib/utils/strategyRunCreation.d.ts

@@ -0,0 +1,8 @@
+import type { TerminalConst } from '../types.js';
+import type { ExecutionJson, StatefulStrategyJson, StrategyRunJson, StrategyRunStatusJson, StrategyStateJson } from '@toolproof-npm/schema';
+export type GetNewIdentity = (identifiable: TerminalConst) => string | Promise<string>;
+export declare function normalizeExecutionInputBindingMap(execution: ExecutionJson, strategyState: StrategyStateJson): ExecutionJson;
+export declare function createStrategyRun(statefulStrategy: StatefulStrategyJson, opts?: {
+    getNewIdentity: GetNewIdentity;
+    status?: StrategyRunStatusJson;
+}): Promise<StrategyRunJson>;

package/dist/_lib/utils/strategyRunCreation.js

@@ -0,0 +1,247 @@
+import { CONSTANTS } from '../../constants.js';
+export 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]));
+    const adj = new Map(); // undirected graph for components
+    steps.forEach((step, i) => {
+        const id = getStepId(step, i);
+        if (!adj.has(id))
+            adj.set(id, []);
+        if (step.kind === CONSTANTS.STEPS.work && step.execution) {
+            const inputBindingMap = step.execution.roleBindings.inputBindingMap;
+            for (const inputRoleId of Object.keys(inputBindingMap)) {
+                const entry = strategyState?.[id]?.[inputRoleId];
+                if (entry?.kind === 'potential-input') {
+                    const creatorId = entry.creationContext?.executionRef;
+                    if (creatorId && stepById.has(creatorId)) {
+                        // Dependency exists
+                        adj.get(id).push(creatorId);
+                        if (!adj.has(creatorId))
+                            adj.set(creatorId, []);
+                        adj.get(creatorId).push(id);
+                    }
+                }
+            }
+        }
+    });
+    const visited = new Set();
+    const components = [];
+    for (const [id] of adj) {
+        if (!visited.has(id)) {
+            const component = [];
+            const queue = [id];
+            visited.add(id);
+            while (queue.length > 0) {
+                const node = queue.shift();
+                component.push(node);
+                for (const neighbor of adj.get(node) || []) {
+                    if (!visited.has(neighbor)) {
+                        visited.add(neighbor);
+                        queue.push(neighbor);
+                    }
+                }
+            }
+            components.push(component);
+        }
+    }
+    return components
+        .map((compIds) => {
+        return steps.filter((s, i) => {
+            const sId = getStepId(s, i);
+            return compIds.includes(sId);
+        });
+    })
+        .filter((group) => group.length > 0);
+}
+export async function createStrategyRun(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 = normalizedStatefulStrategy.statelessStrategy?.steps ?? [];
+    const strategyState = (normalizedStatefulStrategy.strategyState ?? {});
+    // Algorithm to find what steps can run in parallel
+    const threadStepsGroups = getIndependentThreads(steps, strategyState);
+    const strategyThreadMap = {};
+    for (const group of threadStepsGroups) {
+        const threadIdentity = await opts.getNewIdentity(CONSTANTS.TERMINALS.strategy_thread);
+        strategyThreadMap[threadIdentity] = group;
+    }
+    return {
+        identity: strategyRunIdentity,
+        statefulStrategyRef: normalizedStatefulStrategy.identity,
+        strategyState: strategyState,
+        strategyRunContext: {
+            status: opts.status ?? 'running',
+        },
+        strategyThreadMap,
+    };
+}

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export * as TYPES from './_lib/types.js';
 export * as UTILS from './_lib/utils/utils.js';
 export * as RESOURCE_CREATION from './_lib/utils/resourceCreation.js';
 export * as STEP_CREATION from './_lib/utils/stepCreation.js';
-export * as PARALLELIZATION from './_lib/utils/parallelization.js';
+export * as STRATEGY_RUN_CREATION from './_lib/utils/strategyRunCreation.js';
 export * as ROLE_RESOURCE_BINDINGS from './_lib/utils/roleResourceBinding.js';
 export * as RESOURCE_CHAIN from './_lib/utils/resourceChain.js';
 export * from './firebaseAdminHelpers.js';

package/dist/index.js

@@ -3,7 +3,7 @@ export * as TYPES from './_lib/types.js';
 export * as UTILS from './_lib/utils/utils.js';
 export * as RESOURCE_CREATION from './_lib/utils/resourceCreation.js';
 export * as STEP_CREATION from './_lib/utils/stepCreation.js';
-export * as PARALLELIZATION from './_lib/utils/parallelization.js';
+export * as STRATEGY_RUN_CREATION from './_lib/utils/strategyRunCreation.js';
 export * as ROLE_RESOURCE_BINDINGS from './_lib/utils/roleResourceBinding.js';
 export * as RESOURCE_CHAIN from './_lib/utils/resourceChain.js';
 export * from './firebaseAdminHelpers.js';

package/package.json

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