@toolproof-npm/shared 0.1.117 → 0.1.119

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

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

package/dist/_lib/utils/runnableStrategyCreation.js

@@ -0,0 +1,194 @@
+import { CONSTANTS } from '../../constants.js';
+import { getIndependentThreads } from './parallelization.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,
+        },
+    };
+}
+export async function createRunnableStrategy(statefulStrategy, opts) {
+    if (!opts?.getNewIdentity) {
+        throw new Error('statefulStrategyToRunnableStrategy: 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 runnableStrategyIdentity = (await opts.getNewIdentity(CONSTANTS.IDENTITY_PREFIXES.runnable_strategy));
+    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.IDENTITY_PREFIXES.strategy_thread);
+        strategyThreadMap[threadIdentity] = group;
+    }
+    return {
+        identity: runnableStrategyIdentity,
+        statefulStrategyRef: normalizedStatefulStrategy.identity,
+        strategyState: strategyState,
+        runnableStrategyContext: {
+            status: opts.status ?? 'running',
+        },
+        strategyThreadMap,
+    };
+}

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

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

package/dist/_lib/utils/strategyRunCreation.js

@@ -165,14 +165,14 @@ function normalizeStatefulStrategyInputBindingMaps(statefulStrategy) {
         },
     };
 }
-export async function createStrategyRun(statefulStrategy, opts) {
+export async function createRunnableStrategy(statefulStrategy, opts) {
     if (!opts?.getNewIdentity) {
-        throw new Error('statefulStrategyToStrategyRun: opts.getNewIdentity is required');
+        throw new Error('statefulStrategyToRunnableStrategy: 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.IDENTITY_PREFIXES.strategy_run));
+    const runnableStrategyIdentity = (await opts.getNewIdentity(CONSTANTS.IDENTITY_PREFIXES.strategy_run));
     const steps = normalizedStatefulStrategy.statelessStrategy?.steps ?? [];
     const strategyState = (normalizedStatefulStrategy.strategyState ?? {});
     // Algorithm to find what steps can run in parallel
@@ -183,10 +183,10 @@ export async function createStrategyRun(statefulStrategy, opts) {
         strategyThreadMap[threadIdentity] = group;
     }
     return {
-        identity: strategyRunIdentity,
+        identity: runnableStrategyIdentity,
         statefulStrategyRef: normalizedStatefulStrategy.identity,
         strategyState: strategyState,
-        strategyRunContext: {
+        runnableStrategyContext: {
             status: opts.status ?? 'running',
         },
         strategyThreadMap,

package/dist/constants.d.ts

@@ -25,7 +25,7 @@ export declare const CONSTANTS: {
         readonly stateless_strategy: "stateless_strategy";
         readonly stateful_strategy: "stateful_strategy";
         readonly strategy_thread: "strategy_thread";
-        readonly strategy_run: "strategy_run";
+        readonly runnable_strategy: "runnable_strategy";
     };
     readonly STEPS: {
         readonly work: "work";
@@ -59,18 +59,18 @@ export declare const CONSTANTS: {
         readonly TYPE_Error: "TYPE-Error";
         readonly TYPE_StatelessStrategy: "TYPE-StatelessStrategy";
         readonly TYPE_StatefulStrategy: "TYPE-StatefulStrategy";
-        readonly TYPE_StrategyRun: "TYPE-StrategyRun";
+        readonly TYPE_RunnableStrategy: "TYPE-RunnableStrategy";
         readonly TYPE_RunRecording: "TYPE-RunRecording";
         readonly ROLE_Manual: "ROLE-Manual";
         readonly ROLE_Iteration: "ROLE-Iteration";
         readonly ROLE_ErrorOutput: "ROLE-ErrorOutput";
-        readonly ROLE_DynamicSource: "ROLE-u4vW7PDlX6V9IGJoNxhl";
-        readonly ROLE_StaticTarget: "ROLE-xLaQo8L1fMxKTQUJcaJn";
-        readonly ROLE_Decison: "ROLE-C4FKVwXipgngzPQc3MDc";
+        readonly ROLE_LessThanSource: "ROLE-LessThanSource";
+        readonly ROLE_LessThanTarget: "ROLE-LessThanTarget";
+        readonly ROLE_Decision: "ROLE-Decision";
         readonly JOB_Engine: "JOB-Engine";
         readonly JOB_LessThan: "JOB-LessThan";
-        readonly BOOLEAN_false: "RESOURCE-qadnfFGjZsjpqLI0Du1d";
-        readonly BOOLEAN_true: "RESOURCE-iZX1cxZ9ImJRzty9Ob4G";
+        readonly BOOLEAN_false: "RESOURCE-BooleanFalse";
+        readonly BOOLEAN_true: "RESOURCE-BooleanTrue";
     };
     readonly TESTING: {
         readonly Natural_Zero: "TYPE-Natural/3335e31095a13a9a2b0ea41ca7d92a458780cd5671dc0a440a72cc1b1c4f2c81";

package/dist/constants.js

@@ -25,7 +25,7 @@ export const CONSTANTS = {
         stateless_strategy: 'stateless_strategy',
         stateful_strategy: 'stateful_strategy',
         strategy_thread: 'strategy_thread',
-        strategy_run: 'strategy_run',
+        runnable_strategy: 'runnable_strategy',
     },
     STEPS: {
         work: 'work',
@@ -59,18 +59,18 @@ export const CONSTANTS = {
         TYPE_Error: 'TYPE-Error',
         TYPE_StatelessStrategy: 'TYPE-StatelessStrategy',
         TYPE_StatefulStrategy: 'TYPE-StatefulStrategy',
-        TYPE_StrategyRun: 'TYPE-StrategyRun',
+        TYPE_RunnableStrategy: 'TYPE-RunnableStrategy',
         TYPE_RunRecording: 'TYPE-RunRecording',
         ROLE_Manual: 'ROLE-Manual',
         ROLE_Iteration: 'ROLE-Iteration',
         ROLE_ErrorOutput: 'ROLE-ErrorOutput',
-        ROLE_DynamicSource: 'ROLE-u4vW7PDlX6V9IGJoNxhl',
-        ROLE_StaticTarget: 'ROLE-xLaQo8L1fMxKTQUJcaJn',
-        ROLE_Decison: 'ROLE-C4FKVwXipgngzPQc3MDc',
+        ROLE_LessThanSource: 'ROLE-LessThanSource',
+        ROLE_LessThanTarget: 'ROLE-LessThanTarget',
+        ROLE_Decision: 'ROLE-Decision',
         JOB_Engine: 'JOB-Engine',
         JOB_LessThan: 'JOB-LessThan',
-        BOOLEAN_false: 'RESOURCE-qadnfFGjZsjpqLI0Du1d',
-        BOOLEAN_true: 'RESOURCE-iZX1cxZ9ImJRzty9Ob4G',
+        BOOLEAN_false: 'RESOURCE-BooleanFalse',
+        BOOLEAN_true: 'RESOURCE-BooleanTrue',
     },
     TESTING: {
         Natural_Zero: 'TYPE-Natural/3335e31095a13a9a2b0ea41ca7d92a458780cd5671dc0a440a72cc1b1c4f2c81',

package/dist/firebaseAdminHelpers.d.ts

@@ -1,4 +1,4 @@
-import type { BranchStepIdentityJson, ExecutionIdentityJson, ForStepIdentityJson, JobIdentityJson, ResourceFormatIdentityJson, ResourceIdentityJson, ResourceRoleIdentityJson, ResourceTypeIdentityJson, StatefulStrategyIdentityJson, StatelessStrategyIdentityJson, StrategyRunIdentityJson, StrategyThreadIdentityJson, WhileStepIdentityJson, WorkStepIdentityJson } from '@toolproof-npm/schema';
+import type { BranchStepIdentityJson, ExecutionIdentityJson, ForStepIdentityJson, JobIdentityJson, ResourceFormatIdentityJson, ResourceIdentityJson, ResourceRoleIdentityJson, ResourceTypeIdentityJson, StatefulStrategyIdentityJson, StatelessStrategyIdentityJson, RunnableStrategyIdentityJson, StrategyThreadIdentityJson, WhileStepIdentityJson, WorkStepIdentityJson } from '@toolproof-npm/schema';
 import type { ResourceMap, IdentityPrefix } from './_lib/types.js';
 import { CONSTANTS } from './constants.js';
 type StripTrailingS<S extends string> = S extends `${infer Rest}S` ? Rest : S;
@@ -17,7 +17,7 @@ type IdentityJsonByPrefix = {
     stateless_strategy: StatelessStrategyIdentityJson;
     stateful_strategy: StatefulStrategyIdentityJson;
     strategy_thread: StrategyThreadIdentityJson;
-    strategy_run: StrategyRunIdentityJson;
+    runnable_strategy: RunnableStrategyIdentityJson;
 };
 export type NewIdentity<T extends AnyIdentityPrefix = AnyIdentityPrefix> = T extends keyof IdentityJsonByPrefix ? IdentityJsonByPrefix[T] : T extends StepIdentityPrefix ? StepIdentityForPrefix<T> : `${IdentityPrefixFor<T>}-${string}`;
 export declare function getNewIdentity<T extends AnyIdentityPrefix>(identifiable: T): NewIdentity<T>;

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 STRATEGY_RUN_CREATION from './_lib/utils/strategyRunCreation.js';
+export * as RUNNABLE_STRATEGY_CREATION from './_lib/utils/runnableStrategyCreation.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 STRATEGY_RUN_CREATION from './_lib/utils/strategyRunCreation.js';
+export * as RUNNABLE_STRATEGY_CREATION from './_lib/utils/runnableStrategyCreation.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.117",
+  "version": "0.1.119",
   "description": "Core library utilities for ToolProof",
   "keywords": [
     "toolproof",
@@ -56,7 +56,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@toolproof-npm/schema": "^0.1.82",
+    "@toolproof-npm/schema": "^0.1.83",
     "firebase-admin": "^13.6.0"
   },
   "scripts": {