@toolproof-npm/shared 0.1.104 → 0.1.106

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

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

package/dist/_lib/utils/parallelization.js

@@ -0,0 +1,79 @@
+import { CONSTANTS } from '../../constants.js';
+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 statefulStrategyToStrategyRun(statefulStrategy, opts) {
+    if (!opts?.getNewIdentity) {
+        throw new Error('statefulStrategyToStrategyRun: opts.getNewIdentity is required');
+    }
+    const strategyRunIdentity = (await opts.getNewIdentity(CONSTANTS.TERMINALS.strategy_run));
+    const steps = statefulStrategy.statelessStrategy?.steps ?? [];
+    const strategyState = (statefulStrategy.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: statefulStrategy.identity,
+        strategyState: strategyState,
+        strategyRunContext: {
+            status: opts.status ?? 'running',
+        },
+        strategyThreadMap,
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { TerminalConst } from '../types.js';
+import type { StatefulStrategyJson, StrategyRunJson, StrategyRunStatusJson } from '@toolproof-npm/schema';
+export type GetNewIdentity = (identifiable: TerminalConst) => string;
+export declare function statefulStrategyToStrategyRun(statefulStrategy: StatefulStrategyJson, opts?: {
+    getNewIdentity: GetNewIdentity;
+    status?: StrategyRunStatusJson;
+}): StrategyRunJson;

package/dist/_lib/utils/statefulStrategyToStrategyRun.js

@@ -0,0 +1,79 @@
+import { CONSTANTS } from '../../constants.js';
+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 function statefulStrategyToStrategyRun(statefulStrategy, opts) {
+    if (!opts?.getNewIdentity) {
+        throw new Error('statefulStrategyToStrategyRun: opts.getNewIdentity is required');
+    }
+    const strategyRunIdentity = opts.getNewIdentity(CONSTANTS.TERMINALS.strategy_run);
+    const steps = statefulStrategy.statelessStrategy?.steps ?? [];
+    const strategyState = (statefulStrategy.strategyState ?? {});
+    // Algorithm to find what steps can run in parallel
+    const threadStepsGroups = getIndependentThreads(steps, strategyState);
+    const strategyThreadMap = {};
+    threadStepsGroups.forEach((group) => {
+        const threadIdentity = opts.getNewIdentity(CONSTANTS.TERMINALS.strategy_thread);
+        strategyThreadMap[threadIdentity] = group;
+    });
+    return {
+        identity: strategyRunIdentity,
+        statefulStrategyRef: statefulStrategy.identity,
+        strategyState: strategyState,
+        strategyRunContext: {
+            status: opts.status ?? 'running',
+        },
+        strategyThreadMap,
+    };
+}

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

@@ -6,3 +6,5 @@ export declare const createBranchStepFromJobPairs: (cases: {
     whenJob: JobJson;
 }[]) => Promise<BranchStepJson>;
 export declare const cloneForStep: (forStep: ForStepJson) => Promise<ForStepJson>;
+export declare const cloneWhileStep: (whileStep: WhileStepJson) => Promise<WhileStepJson>;
+export declare const cloneBranchStep: (branchStep: BranchStepJson, casesOverride?: BranchStepJson["cases"]) => Promise<BranchStepJson>;

package/dist/_lib/utils/stepCreation.js

@@ -124,3 +124,61 @@ export const cloneForStep = async (forStep) => {
         }
     };
 };
+// DOC: Helper function to clone a WhileStep with new identities for steps and executions, preserving job references and bindings
+export const cloneWhileStep = async (whileStep) => {
+    // Generate new WhileStep identity
+    const newWhileStepIdentity = await getNewIdentity(CONSTANTS.STEPS.while);
+    // Clone the "what" WorkStep
+    const originalWhatWorkStep = whileStep.case.what;
+    const newWhatWorkStepIdentity = await getNewIdentity(CONSTANTS.STEPS.work);
+    const newWhatExecutionIdentity = newWhatWorkStepIdentity.replace(CONSTANTS.STEPS.work.toUpperCase(), 'execution'.toUpperCase());
+    const newWhatExecution = {
+        identity: newWhatExecutionIdentity,
+        jobRef: originalWhatWorkStep.execution.jobRef,
+        roleBindings: {
+            inputBindingMap: { ...originalWhatWorkStep.execution.roleBindings.inputBindingMap },
+            outputBindingMap: { ...originalWhatWorkStep.execution.roleBindings.outputBindingMap }
+        }
+    };
+    const newWhatWorkStep = {
+        identity: newWhatWorkStepIdentity,
+        kind: CONSTANTS.STEPS.work,
+        execution: newWhatExecution
+    };
+    // Clone the "when" WorkStep
+    const originalWhenWorkStep = whileStep.case.when;
+    const newWhenWorkStepIdentity = await getNewIdentity(CONSTANTS.STEPS.work);
+    const newWhenExecutionIdentity = newWhenWorkStepIdentity.replace(CONSTANTS.STEPS.work.toUpperCase(), 'execution'.toUpperCase());
+    const newWhenExecution = {
+        identity: newWhenExecutionIdentity,
+        jobRef: originalWhenWorkStep.execution.jobRef,
+        roleBindings: {
+            inputBindingMap: { ...originalWhenWorkStep.execution.roleBindings.inputBindingMap },
+            outputBindingMap: { ...originalWhenWorkStep.execution.roleBindings.outputBindingMap }
+        }
+    };
+    const newWhenWorkStep = {
+        identity: newWhenWorkStepIdentity,
+        kind: CONSTANTS.STEPS.work,
+        execution: newWhenExecution
+    };
+    // Assemble the cloned WhileStep
+    return {
+        identity: newWhileStepIdentity,
+        kind: CONSTANTS.STEPS.while,
+        case: {
+            what: newWhatWorkStep,
+            when: newWhenWorkStep
+        }
+    };
+};
+// DOC: Helper function to clone a BranchStep with a new identity, optionally overriding its cases.
+// Note: We intentionally do NOT clone executions/steps here because BranchStep (Option A) does not repeat cases.
+export const cloneBranchStep = async (branchStep, casesOverride) => {
+    const newBranchStepIdentity = await getNewIdentity(CONSTANTS.STEPS.branch);
+    return {
+        identity: newBranchStepIdentity,
+        kind: CONSTANTS.STEPS.branch,
+        cases: casesOverride ?? branchStep.cases,
+    };
+};

package/dist/index.d.ts

@@ -3,6 +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 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,6 +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 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.104",
+  "version": "0.1.106",
   "description": "Core library utilities for ToolProof",
   "keywords": [
     "toolproof",
@@ -56,7 +56,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@toolproof-npm/schema": "^0.1.68",
+    "@toolproof-npm/schema": "^0.1.72",
     "firebase-admin": "^13.6.0"
   },
   "scripts": {