@toolproof-core/lib 1.0.46 → 1.0.48

package/dist/lookups/lookups.d.ts

@@ -68,6 +68,11 @@ export declare const CONSTANTS: {
         readonly StepArrayArray: "StepArrayArray";
         readonly StepKind: "StepKind";
         readonly StepKindFacet: "StepKindFacet";
+        readonly StepPath: "StepPath";
+        readonly StepPathSegment: "StepPathSegment";
+        readonly StepPathSegmentKind: "StepPathSegmentKind";
+        readonly StepPathSlot: "StepPathSlot";
+        readonly StepPathSpec: "StepPathSpec";
         readonly StepsByThreadIndexFacet: "StepsByThreadIndexFacet";
         readonly StepsFacet: "StepsFacet";
         readonly Strategy: "Strategy";
@@ -189,6 +194,10 @@ export declare const CONSTANTS: {
             readonly while: "while";
             readonly for: "for";
         };
+        readonly StepPathSegmentKind: {
+            readonly case: "case";
+            readonly cases: "cases";
+        };
         readonly StrategyStateEntryKind: {
             readonly materializedResource: "materializedResource";
             readonly externalInputPotential: "externalInputPotential";

package/dist/utils/mutableStrategyOverlay.d.ts

@@ -1,55 +1,60 @@
 import type { BranchStep, Case, ExternalInputPotential, ForStep, MaterializedResource, InternalInputPotential, Resource, RoleName, Strategy, Tool, ToolHandle, ToolStep, ToolStepRoleAddress, WhileStep } from '@toolproof-core/genesis';
-export type MutableToolStepKey = string;
-export type MutableBranchStepKey = string;
-export type MutableWhileStepKey = string;
-export type MutableForStepKey = string;
+export type MutableToolStepKey = `TOOL_STEP-${string}`;
+export type MutableBranchStepKey = `BRANCH_STEP-${string}`;
+export type MutableWhileStepKey = `WHILE_STEP-${string}`;
+export type MutableForStepKey = `FOR_STEP-${string}`;
 export type MutableLoopStepKey = MutableWhileStepKey | MutableForStepKey;
 export type MutableMacroStepKey = MutableBranchStepKey | MutableLoopStepKey;
+export type MutableStepKey = MutableToolStepKey | MutableMacroStepKey;
 export type MutableMaterializedResource = MaterializedResource;
-export type MutableToolStepRoleAddress<TKey extends string = MutableToolStepKey> = Omit<ToolStepRoleAddress, 'toolStepPath'> & {
-    toolStepKey: TKey;
+export type MutableToolStepRoleAddress = Omit<ToolStepRoleAddress, 'toolStepPath'> & {
+    stepKey: MutableToolStepKey;
+    toolStepKey: MutableToolStepKey;
 };
-export type MutableInternalInputPotential<TKey extends string = MutableToolStepKey> = Omit<InternalInputPotential, 'toolStepRoleAddress'> & {
-    toolStepRoleAddress: MutableToolStepRoleAddress<TKey>;
+export type MutableInternalInputPotential = Omit<InternalInputPotential, 'toolStepRoleAddress'> & {
+    toolStepRoleAddress: MutableToolStepRoleAddress;
 };
 export type MutableExternalInputPotential = ExternalInputPotential;
-export type MutableStrategyStateEntry<TKey extends string = MutableToolStepKey> = MutableMaterializedResource | MutableInternalInputPotential<TKey> | MutableExternalInputPotential;
-export type MutableStrategyStateEntryByRoleName<TKey extends string = MutableToolStepKey> = Partial<Record<RoleName, MutableStrategyStateEntry<TKey>>>;
-export type MutableStrategyState<TKey extends string = MutableToolStepKey> = Partial<Record<TKey, MutableStrategyStateEntryByRoleName<TKey>>>;
-export type MutableToolStep<TKey extends string = MutableToolStepKey> = ToolStep & {
-    toolStepKey: TKey;
-};
-export type MutableCase<TKey extends string = MutableToolStepKey> = Omit<Case, 'when' | 'what'> & {
-    when: MutableToolStep<TKey>;
-    what: MutableToolStep<TKey>;
-};
-export type MutableBranchStep<TKey extends string = MutableToolStepKey> = Omit<BranchStep, 'cases'> & {
+export type MutableStrategyStateEntry = MutableMaterializedResource | MutableInternalInputPotential | MutableExternalInputPotential;
+export type MutableStrategyStateEntryByRoleName = Partial<Record<RoleName, MutableStrategyStateEntry>>;
+export type MutableStrategyState = Partial<Record<MutableToolStepKey, MutableStrategyStateEntryByRoleName>>;
+export type MutableToolStep = ToolStep & {
+    stepKey: MutableToolStepKey;
+    toolStepKey: MutableToolStepKey;
+};
+export type MutableCase = Omit<Case, 'when' | 'what'> & {
+    when: MutableToolStep;
+    what: MutableToolStep;
+};
+export type MutableBranchStep = Omit<BranchStep, 'cases'> & {
+    stepKey: MutableBranchStepKey;
     macroStepKey: MutableBranchStepKey;
-    cases: [MutableCase<TKey>, ...MutableCase<TKey>[]];
+    cases: [MutableCase, ...MutableCase[]];
 };
-export type MutableWhileStep<TKey extends string = MutableToolStepKey> = Omit<WhileStep, 'case'> & {
+export type MutableWhileStep = Omit<WhileStep, 'case'> & {
+    stepKey: MutableWhileStepKey;
     macroStepKey: MutableWhileStepKey;
-    case: MutableCase<TKey>;
+    case: MutableCase;
 };
-export type MutableForStep<TKey extends string = MutableToolStepKey> = Omit<ForStep, 'case'> & {
+export type MutableForStep = Omit<ForStep, 'case'> & {
+    stepKey: MutableForStepKey;
     macroStepKey: MutableForStepKey;
-    case: MutableCase<TKey>;
-};
-export type MutableStep<TKey extends string = MutableToolStepKey> = MutableToolStep<TKey> | MutableBranchStep<TKey> | MutableWhileStep<TKey> | MutableForStep<TKey>;
-export type MutableStrategy<TKey extends string = MutableToolStepKey, TStep extends MutableStep<TKey> = MutableStep<TKey>, TState extends MutableStrategyState<TKey> = MutableStrategyState<TKey>> = Omit<Strategy, 'stepsByThreadIndex' | 'strategyState'> & {
-    stepsByThreadIndex: TStep[][];
-    strategyState: TState;
-};
-export declare function getAuthoringSteps<TKey extends string = MutableToolStepKey, TStep extends MutableStep<TKey> = MutableStep<TKey>, TState extends MutableStrategyState<TKey> = MutableStrategyState<TKey>>(strategy: MutableStrategy<TKey, TStep, TState>): TStep[];
-export declare function setAuthoringSteps<// ATTENTION
-TKey extends string = MutableToolStepKey, TStep extends MutableStep<TKey> = MutableStep<TKey>, TState extends MutableStrategyState<TKey> = MutableStrategyState<TKey>>(strategy: MutableStrategy<TKey, TStep, TState>, steps: TStep[]): MutableStrategy<TKey, TStep, TState>;
-export declare function getStrategyStateEntryByRoleName<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepKey: TKey): MutableStrategyStateEntryByRoleName<TKey> | undefined;
-export declare function getStrategyStateEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress<TKey>): MutableStrategyStateEntry<TKey> | undefined;
-export declare function setStrategyStateEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress<TKey>, entry: MutableStrategyStateEntry<TKey>): TStrategyState;
-export declare function clearInputBinding<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress<TKey>): TStrategyState;
-export declare function bindMaterializedResource<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, target: MutableToolStepRoleAddress<TKey>, resource: Resource): TStrategyState;
-export declare function bindInternalInputPotential<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, targetAddress: MutableToolStepRoleAddress<TKey>, sourceAddress: MutableToolStepRoleAddress<TKey>, context: {
-    toolStepByKey: ReadonlyMap<TKey, MutableToolStep<TKey>>;
+    case: MutableCase;
+};
+export type MutableStep = MutableToolStep | MutableBranchStep | MutableWhileStep | MutableForStep;
+export type MutableStrategy = Omit<Strategy, 'stepsByThreadIndex' | 'strategyState'> & {
+    stepsByThreadIndex: MutableStep[][];
+    strategyState: MutableStrategyState;
+};
+export declare function getAuthoringSteps(strategy: MutableStrategy): MutableStep[];
+export declare function setAuthoringSteps(strategy: MutableStrategy, steps: MutableStep[]): MutableStrategy;
+export declare function getStrategyStateEntryByRoleName(strategyState: MutableStrategyState, toolStepKey: MutableToolStepKey): MutableStrategyStateEntryByRoleName | undefined;
+export declare function getStrategyStateEntry(strategyState: MutableStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress): MutableStrategyStateEntry | undefined;
+export declare function setStrategyStateEntry(strategyState: MutableStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress, entry: MutableStrategyStateEntry): MutableStrategyState;
+export declare function clearInputBinding(strategyState: MutableStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress): MutableStrategyState;
+export declare function bindMaterializedResource(strategyState: MutableStrategyState, target: MutableToolStepRoleAddress, resource: Resource): MutableStrategyState;
+export declare function bindInternalInputPotential(strategyState: MutableStrategyState, targetAddress: MutableToolStepRoleAddress, sourceAddress: MutableToolStepRoleAddress, context: {
+    toolStepByKey: ReadonlyMap<MutableToolStepKey, MutableToolStep>;
     toolMap: ReadonlyMap<ToolHandle, Tool>;
-}): TStrategyState;
-export declare function bindExternalInputPotential<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, target: MutableToolStepRoleAddress<TKey>): TStrategyState;
+}): MutableStrategyState;
+export declare function bindExternalInputPotential(strategyState: MutableStrategyState, target: MutableToolStepRoleAddress): MutableStrategyState;

package/dist/utils/mutableStrategyOverlay.js

@@ -102,6 +102,7 @@ export function bindInternalInputPotential(strategyState, targetAddress, sourceA
     return setStrategyStateEntry(strategyState, targetAddress, {
         strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
+            stepKey: sourceAddress.stepKey,
             toolStepKey: sourceAddress.toolStepKey,
             roleName: sourceAddress.roleName,
         },

package/dist/utils/stepCreation.d.ts

@@ -1,7 +1,8 @@
-import type { Tool } from '@toolproof-core/genesis';
+import type { Tool, WhenInputRoleBindingSpec } from '@toolproof-core/genesis';
 import type { MutableToolStep, MutableCase, MutableWhileStep, MutableForStep, MutableBranchStep } from './mutableStrategyOverlay.js';
 import { CONSTANTS } from '../lookups/lookups.js';
 export declare function createToolStepFromTool(tool: Tool): MutableToolStep;
+export declare function createLoopSlotWhenToolStepFromTool(tool: Tool, whenInputRoleBindingSpec: WhenInputRoleBindingSpec): MutableToolStep;
 export declare function createCaseFromToolStepPair(what: MutableToolStep, when: MutableToolStep): MutableCase;
 export declare function createLoopStepFromCase(stepCase: MutableCase, stepKind: typeof CONSTANTS.Enums.StepKind.for | typeof CONSTANTS.Enums.StepKind.while): MutableForStep | MutableWhileStep;
 export declare function createBranchStepFromCases(cases: MutableCase[]): MutableBranchStep;

package/dist/utils/stepCreation.js

@@ -14,24 +14,33 @@ function getRoleBindingSpec(tool) {
 }
 export function createToolStepFromTool(tool) {
     return {
+        stepKey: generateIdentifier('ToolStepKey'),
         toolStepKey: generateIdentifier('ToolStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.tool,
         toolHandle: tool.handle,
         roleBindingSpec: getRoleBindingSpec(tool),
     };
 }
+export function createLoopSlotWhenToolStepFromTool(tool, whenInputRoleBindingSpec) {
+    return {
+        ...createToolStepFromTool(tool),
+        whenInputRoleBindingSpec,
+    };
+}
 export function createCaseFromToolStepPair(what, when) {
     return { what, when };
 }
 export function createLoopStepFromCase(stepCase, stepKind) {
     if (stepKind === CONSTANTS.Enums.StepKind.for) {
         return {
+            stepKey: generateIdentifier('ForStepKey'),
             macroStepKey: generateIdentifier('ForStepKey'),
             stepKind: CONSTANTS.Enums.StepKind.for,
             case: stepCase,
         };
     }
     return {
+        stepKey: generateIdentifier('WhileStepKey'),
         macroStepKey: generateIdentifier('WhileStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.while,
         case: stepCase,
@@ -40,6 +49,7 @@ export function createLoopStepFromCase(stepCase, stepKind) {
 export function createBranchStepFromCases(cases) {
     assertNonEmpty(cases, 'createBranchStepFromCases requires at least one case');
     return {
+        stepKey: generateIdentifier('BranchStepKey'),
         macroStepKey: generateIdentifier('BranchStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.branch,
         cases,
@@ -47,6 +57,7 @@ export function createBranchStepFromCases(cases) {
 }
 export function cloneForStep(forStep) {
     return {
+        stepKey: generateIdentifier('ForStepKey'),
         macroStepKey: generateIdentifier('ForStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.for,
         case: {
@@ -63,6 +74,7 @@ export function cloneForStep(forStep) {
 }
 export function cloneWhileStep(whileStep) {
     return {
+        stepKey: generateIdentifier('WhileStepKey'),
         macroStepKey: generateIdentifier('WhileStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.while,
         case: {

package/dist/utils/stepExpansion.d.ts

@@ -1,6 +1,6 @@
-import type { MutableStep, MutableToolStep, MutableToolStepKey } from './mutableStrategyOverlay.js';
+import type { MutableStep, MutableToolStep } from './mutableStrategyOverlay.js';
 export type StepExpansionOrder = {
     branchCaseOrder?: 'when-what' | 'what-when';
     loopCaseOrder?: 'what-when' | 'when-what';
 };
-export declare function extractToolStepsFromStep<TKey extends string = MutableToolStepKey, TStep extends MutableStep<TKey> = MutableStep<TKey>>(step: TStep, order?: StepExpansionOrder): MutableToolStep<TKey>[];
+export declare function extractToolStepsFromStep(step: MutableStep, order?: StepExpansionOrder): MutableToolStep[];

package/dist/utils/stepExpansion.js

@@ -5,28 +5,28 @@ export function extractToolStepsFromStep(step, order = {}) {
         return [step];
     }
     if (step.stepKind === CONSTANTS.Enums.StepKind.branch) {
-        const branch = step;
-        const cases = branch.cases ?? [];
+        const branchStep = step;
+        const cases = branchStep.cases ?? [];
         return cases.flatMap((stepCase) => {
             if (branchCaseOrder === 'what-when') {
                 return [stepCase.what, stepCase.when];
             }
             return [stepCase.when, stepCase.what];
-        }).filter(Boolean);
+        });
     }
     if (step.stepKind === CONSTANTS.Enums.StepKind.while) {
-        const loop = step;
+        const whileStep = step;
         if (loopCaseOrder === 'when-what') {
-            return [loop.case.when, loop.case.what].filter(Boolean);
+            return [whileStep.case.when, whileStep.case.what];
         }
-        return [loop.case.what, loop.case.when].filter(Boolean);
+        return [whileStep.case.what, whileStep.case.when];
     }
     if (step.stepKind === CONSTANTS.Enums.StepKind.for) {
-        const loop = step;
+        const forStep = step;
         if (loopCaseOrder === 'when-what') {
-            return [loop.case.when, loop.case.what].filter(Boolean);
+            return [forStep.case.when, forStep.case.what];
         }
-        return [loop.case.what, loop.case.when].filter(Boolean);
+        return [forStep.case.what, forStep.case.when];
     }
     return [];
 }

package/dist/utils/stepParallelization.d.ts

@@ -1,2 +1,2 @@
-import type { MutableStep, MutableStrategyState, MutableToolStepKey } from './mutableStrategyOverlay.js';
-export declare function getIndependentThreads<TKey extends string = MutableToolStepKey, TStep extends MutableStep<TKey> = MutableStep<TKey>>(steps: TStep[], strategyState: MutableStrategyState<TKey>): TStep[][];
+import type { MutableStep, MutableStrategyState } from './mutableStrategyOverlay.js';
+export declare function getIndependentThreads(steps: MutableStep[], strategyState: MutableStrategyState): MutableStep[][];

package/dist/utils/strategyAssembly.d.ts

@@ -1,3 +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;
+export declare function composeStrategyForExecution(mutableStrategy: MutableStrategy): Strategy;

package/dist/utils/strategyCanonicalization.js

@@ -2,8 +2,8 @@ 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;
+    const { stepKey: _whenStepKey, toolStepKey: _whenToolStepKey, ...canonicalWhen } = when;
+    const { stepKey: _whatStepKey, toolStepKey: _whatToolStepKey, ...canonicalWhat } = what;
     return {
         ...rest,
         when: canonicalWhen,
@@ -58,11 +58,11 @@ function toCanonicalStrategyStateEntry(entry, executionPathByKey) {
 function toCanonicalStep(step) {
     switch (step.stepKind) {
         case CONSTANTS.Enums.StepKind.tool: {
-            const { toolStepKey: _toolStepKey, ...canonicalToolStep } = step;
+            const { stepKey: _stepKey, toolStepKey: _toolStepKey, ...canonicalToolStep } = step;
             return canonicalToolStep;
         }
         case CONSTANTS.Enums.StepKind.branch: {
-            const { macroStepKey: _macroStepKey, cases, ...rest } = step;
+            const { stepKey: _stepKey, macroStepKey: _macroStepKey, cases, ...rest } = step;
             return {
                 ...rest,
                 cases: cases.map(stripMutableCase),
@@ -70,7 +70,7 @@ function toCanonicalStep(step) {
         }
         case CONSTANTS.Enums.StepKind.while:
         case CONSTANTS.Enums.StepKind.for: {
-            const { macroStepKey: _macroStepKey, case: stepCase, ...rest } = step;
+            const { stepKey: _stepKey, macroStepKey: _macroStepKey, case: stepCase, ...rest } = step;
             return {
                 ...rest,
                 case: stripMutableCase(stepCase),
@@ -91,15 +91,18 @@ function toMutableStrategyStateEntry(entry, executionKeyByPath) {
     return {
         strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
+            stepKey: sourceToolStepKey,
             toolStepKey: sourceToolStepKey,
             roleName: entry.toolStepRoleAddress.roleName,
         },
     };
 }
 function toMutableToolStep(step) {
+    const key = generateIdentifier('ToolStepKey');
     return {
         ...step,
-        toolStepKey: generateIdentifier('ToolStepKey'),
+        stepKey: key,
+        toolStepKey: key,
     };
 }
 function toMutableCase(stepCase) {
@@ -112,25 +115,31 @@ function toMutableCase(stepCase) {
 }
 function toMutableBranchStep(step) {
     const { cases, ...rest } = step;
+    const key = generateIdentifier('BranchStepKey');
     return {
         ...rest,
-        macroStepKey: generateIdentifier('BranchStepKey'),
+        stepKey: key,
+        macroStepKey: key,
         cases: cases.map(toMutableCase),
     };
 }
 function toMutableWhileStep(step) {
     const { case: stepCase, ...rest } = step;
+    const key = generateIdentifier('WhileStepKey');
     return {
         ...rest,
-        macroStepKey: generateIdentifier('WhileStepKey'),
+        stepKey: key,
+        macroStepKey: key,
         case: toMutableCase(stepCase),
     };
 }
 function toMutableForStep(step) {
     const { case: stepCase, ...rest } = step;
+    const key = generateIdentifier('ForStepKey');
     return {
         ...rest,
-        macroStepKey: generateIdentifier('ForStepKey'),
+        stepKey: key,
+        macroStepKey: key,
         case: toMutableCase(stepCase),
     };
 }

package/dist/utils/strategyStateResolution.d.ts

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

package/dist/utils/strategyThreading.d.ts

@@ -1,2 +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>;
+import type { MutableStrategy } from './mutableStrategyOverlay.js';
+export declare function toExecutionMutableStrategy(mutableStrategy: MutableStrategy): MutableStrategy;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-core/lib",
-  "version": "1.0.46",
+  "version": "1.0.48",
   "description": "",
   "type": "module",
   "keywords": [],
@@ -80,7 +80,7 @@
     "@types/node": "^22.0.0"
   },
   "dependencies": {
-    "@toolproof-core/genesis": "^1.0.62",
+    "@toolproof-core/genesis": "^1.0.65",
     "firebase-admin": "^13.7.0"
   },
   "scripts": {