@toolproof-core/lib 1.0.36 → 1.0.37

package/dist/integrations/firebase/firebaseAdminHelpers.d.ts

@@ -1,4 +1,3 @@
 import type { ResourceTypeHandle } from '@toolproof-core/genesis';
-import type { IdentifierName, IdentifierStringByName, ResourcesByType } from '../../types/types.js';
-export declare function getNewId<K extends IdentifierName>(identifierName: K): IdentifierStringByName<K>;
+import type { ResourcesByType } from '../../types/types.js';
 export declare function listResources(resourceTypeHandles: ResourceTypeHandle[]): Promise<ResourcesByType>;

package/dist/integrations/firebase/firebaseAdminHelpers.js

@@ -1,17 +1,8 @@
-import { CONSTANTS, MAPPINGS } from '../../lookups/lookups.js';
+import { CONSTANTS } from '../../lookups/lookups.js';
 import { dbAdmin, storageAdmin } from './firebaseAdminInit.js';
-export function getNewId(identifierName) {
-    const prefix = MAPPINGS.IdentifierNameToPrefix[identifierName];
-    const docRef = dbAdmin
-        .collection(CONSTANTS.Persistence.Collections.resources)
-        .doc(identifierName)
-        .collection(CONSTANTS.Persistence.Collections.members)
-        .doc();
-    return (prefix + docRef.id);
-}
 export async function listResources(resourceTypeHandles) {
-    const bucketResources = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_resources);
-    const bucketStrategies = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_strategies);
+    const resourcesBucket = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_resources);
+    const strategiesBucket = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_strategies);
     async function fetchTimestampedMetadataUnder(resourceTypeHandle) {
         const snapshot = await dbAdmin
             .collection(CONSTANTS.Persistence.Collections.resources)
@@ -36,8 +27,8 @@ export async function listResources(resourceTypeHandles) {
     }
     async function fetchProjection(resourceTypeHandle, resourceId) {
         const bucket = resourceTypeHandle === CONSTANTS.Handles.ResourceTypes.TYPE_Strategy
-            ? bucketStrategies
-            : bucketResources;
+            ? strategiesBucket
+            : resourcesBucket;
         const file = bucket.file(`${resourceTypeHandle}/${resourceId}`);
         const [exists] = await file.exists();
         if (!exists) {

package/dist/lookups/lookups.d.ts

@@ -15,11 +15,12 @@ export declare const CONSTANTS: {
             readonly GraphBuildStrategy: "GraphBuildStrategy";
         };
     };
+    readonly Cosmos: {
+        readonly ErrorOutputRoleName: "ErrorOutput";
+    };
     readonly Names: {
         readonly AtomicTypeRef: "AtomicTypeRef";
         readonly BaseResource: "BaseResource";
-        readonly BaseStrategy: "BaseStrategy";
-        readonly BaseToolStepPathSpec: "BaseToolStepPathSpec";
         readonly BaseTracePoint: "BaseTracePoint";
         readonly Boolean: "Boolean";
         readonly BranchStep: "BranchStep";
@@ -35,12 +36,9 @@ export declare const CONSTANTS: {
         readonly GenesisProvenance: "GenesisProvenance";
         readonly Goal: "Goal";
         readonly GoalHandle: "GoalHandle";
-        readonly GraphEndTracePoint: "GraphEndTracePoint";
-        readonly GraphStartTracePoint: "GraphStartTracePoint";
         readonly InputPotential: "InputPotential";
         readonly InputResource: "InputResource";
         readonly InternalInputPotential: "InternalInputPotential";
-        readonly InterruptTracePoint: "InterruptTracePoint";
         readonly JsonScalarLink: "JsonScalarLink";
         readonly JsonSchemaObject: "JsonSchemaObject";
         readonly Name: "Name";
@@ -71,9 +69,13 @@ export declare const CONSTANTS: {
         readonly StepsByThreadIndexFacet: "StepsByThreadIndexFacet";
         readonly StepsFacet: "StepsFacet";
         readonly Strategy: "Strategy";
+        readonly StrategyEndTracePoint: "StrategyEndTracePoint";
+        readonly StrategyFacet: "StrategyFacet";
         readonly StrategyHandle: "StrategyHandle";
-        readonly StrategyKind: "StrategyKind";
         readonly StrategyProvenance: "StrategyProvenance";
+        readonly StrategyStartTracePoint: "StrategyStartTracePoint";
+        readonly StrategyState: "StrategyState";
+        readonly StrategyStateFacet: "StrategyStateFacet";
         readonly StrategyStateInputEntry: "StrategyStateInputEntry";
         readonly StrategyStateInputEntryByRoleName: "StrategyStateInputEntryByRoleName";
         readonly StrategyStateInputKind: "StrategyStateInputKind";
@@ -81,12 +83,7 @@ export declare const CONSTANTS: {
         readonly StrategyTraceHandle: "StrategyTraceHandle";
         readonly Suite: "Suite";
         readonly SuiteIngestorInputSchema: "SuiteIngestorInputSchema";
-        readonly ThreadedStrategy: "ThreadedStrategy";
-        readonly ThreadedStrategyFacet: "ThreadedStrategyFacet";
-        readonly ThreadedStrategyState: "ThreadedStrategyState";
-        readonly ThreadedStrategyStateFacet: "ThreadedStrategyStateFacet";
-        readonly ThreadedToolStepPath: "ThreadedToolStepPath";
-        readonly ThreadedToolStepPathSpec: "ThreadedToolStepPathSpec";
+        readonly SuspendedTracePoint: "SuspendedTracePoint";
         readonly TickTracePoint: "TickTracePoint";
         readonly TimestampedResource: "TimestampedResource";
         readonly Tool: "Tool";
@@ -95,17 +92,13 @@ export declare const CONSTANTS: {
         readonly ToolStepPath: "ToolStepPath";
         readonly ToolStepPathSlot: "ToolStepPathSlot";
         readonly ToolStepPathSlotFacet: "ToolStepPathSlotFacet";
+        readonly ToolStepPathSpec: "ToolStepPathSpec";
         readonly ToolStepRoleAddress: "ToolStepRoleAddress";
         readonly TracePoint: "TracePoint";
         readonly TracePointCounterSnapshot: "TracePointCounterSnapshot";
         readonly TracePointDelta: "TracePointDelta";
         readonly TracePointKind: "TracePointKind";
         readonly TypeRef: "TypeRef";
-        readonly UnthreadedStrategy: "UnthreadedStrategy";
-        readonly UnthreadedStrategyState: "UnthreadedStrategyState";
-        readonly UnthreadedStrategyStateFacet: "UnthreadedStrategyStateFacet";
-        readonly UnthreadedToolStepPath: "UnthreadedToolStepPath";
-        readonly UnthreadedToolStepPathSpec: "UnthreadedToolStepPathSpec";
         readonly WhileStep: "WhileStep";
     };
     readonly Handles: {
@@ -192,25 +185,25 @@ export declare const CONSTANTS: {
             readonly while: "while";
             readonly for: "for";
         };
-        readonly StrategyKind: {
-            readonly unthreaded: "unthreaded";
-            readonly threaded: "threaded";
-        };
         readonly StrategyStateInputKind: {
             readonly inputResource: "inputResource";
             readonly externalInputPotential: "externalInputPotential";
             readonly internalInputPotential: "internalInputPotential";
         };
         readonly TracePointKind: {
-            readonly graph_start: "graph_start";
+            readonly strategy_start: "strategy_start";
             readonly tick: "tick";
-            readonly interrupt: "interrupt";
-            readonly graph_end: "graph_end";
+            readonly suspended: "suspended";
+            readonly strategy_end: "strategy_end";
         };
     };
 };
 export declare const MAPPINGS: {
     readonly IdentifierNameToPrefix: {
+        readonly ToolStepKey: "TOOL_STEP-";
+        readonly BranchStepKey: "BRANCH_STEP-";
+        readonly WhileStepKey: "WHILE_STEP-";
+        readonly ForStepKey: "FOR_STEP-";
         readonly GoalHandle: "GOAL-";
         readonly ResourceId: "RESOURCE-";
         readonly ResourceTypeHandle: "TYPE-";

package/dist/lookups/lookups.js

@@ -17,7 +17,17 @@ export const CONSTANTS = {
             GraphBuildStrategy: 'GraphBuildStrategy',
         },
     },
+    Cosmos: {
+        ErrorOutputRoleName: 'ErrorOutput',
+    }
 };
 export const MAPPINGS = {
     ..._MAPPINGS,
+    IdentifierNameToPrefix: {
+        ..._MAPPINGS.IdentifierNameToPrefix,
+        ToolStepKey: 'TOOL_STEP-',
+        BranchStepKey: 'BRANCH_STEP-',
+        WhileStepKey: 'WHILE_STEP-',
+        ForStepKey: 'FOR_STEP-',
+    },
 };

package/dist/types/types.d.ts

@@ -1,16 +1,20 @@
 import type { Resource, ResourceTypeHandle } from '@toolproof-core/genesis/types';
 import { CONSTANTS } from '../lookups/lookups.js';
 import { MAPPINGS } from '../lookups/lookups.js';
-export type Bucket = typeof CONSTANTS.Persistence.Buckets.tp_resources;
+export type Bucket = keyof typeof CONSTANTS.Persistence.Buckets;
 export type Collection = keyof typeof CONSTANTS.Persistence.Collections;
 export type SchemaLike = Record<string, unknown>;
 export type ResourcesByType = Record<ResourceTypeHandle, Resource[]>;
 export type IdentifierName = keyof typeof MAPPINGS.IdentifierNameToPrefix;
 export type IdentifierStringByName<K extends IdentifierName> = `${(typeof MAPPINGS.IdentifierNameToPrefix)[K]}${string}`;
-export interface SmallBaseProjection<T extends string = string> {
-    id: T;
-}
-export interface LargeBaseProjection<T extends string = string> extends SmallBaseProjection<T> {
+export type ItemKey = string;
+export type BaseItem = {
+    itemKey: ItemKey;
+};
+export type DocumentedBaseItem = BaseItem & {
     name: string;
     description: string;
-}
+};
+export type Item = DocumentedBaseItem & {
+    label: string;
+};

package/dist/utils/cosmosDataExtraction.d.ts

@@ -0,0 +1,5 @@
+import type { Resource, TimestampedResource } from '@toolproof-core/genesis';
+export declare function timestampedResourceToResource(timestampedResource: TimestampedResource): Resource;
+export declare function extractProjectionMapByHandle<TKey extends string, TProjection extends {
+    handle: TKey;
+}>(resources: Resource[] | undefined): Map<TKey, TProjection>;

package/dist/utils/cosmosDataExtraction.js

@@ -0,0 +1,15 @@
+export function timestampedResourceToResource(timestampedResource) {
+    const { timestamp: _timestamp, ...resource } = timestampedResource;
+    return resource;
+}
+export function extractProjectionMapByHandle(resources) {
+    const map = new Map();
+    for (const resource of resources ?? []) {
+        const projection = resource.projection;
+        if (!projection || typeof projection !== 'object' || !projection.handle) {
+            continue;
+        }
+        map.set(projection.handle, projection);
+    }
+    return map;
+}

package/dist/utils/identifierGeneration.d.ts

@@ -0,0 +1,2 @@
+import type { IdentifierName, IdentifierStringByName } from '../types/types.js';
+export declare function generateIdentifier<K extends IdentifierName>(identifierName: K): IdentifierStringByName<K>;

package/dist/utils/identifierGeneration.js

@@ -0,0 +1,5 @@
+import { MAPPINGS } from '../lookups/lookups.js';
+export function generateIdentifier(identifierName) {
+    const prefix = MAPPINGS.IdentifierNameToPrefix[identifierName];
+    return (prefix + crypto.randomUUID());
+}

package/dist/utils/mutableStrategyOverlay.d.ts

@@ -0,0 +1,55 @@
+import type { BranchStep, Case, ExternalInputPotential, ForStep, InputResource, 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 MutableLoopStepKey = MutableWhileStepKey | MutableForStepKey;
+export type MutableMacroStepKey = MutableBranchStepKey | MutableLoopStepKey;
+export type MutableInputResource = InputResource;
+export type MutableToolStepRoleAddress<TKey extends string = MutableToolStepKey> = Omit<ToolStepRoleAddress, 'toolStepPath'> & {
+    toolStepKey: TKey;
+};
+export type MutableInternalInputPotential<TKey extends string = MutableToolStepKey> = Omit<InternalInputPotential, 'toolStepRoleAddress'> & {
+    toolStepRoleAddress: MutableToolStepRoleAddress<TKey>;
+};
+export type MutableExternalInputPotential = ExternalInputPotential;
+export type MutableStrategyStateInputEntry<TKey extends string = MutableToolStepKey> = MutableInputResource | MutableInternalInputPotential<TKey> | MutableExternalInputPotential;
+export type MutableStrategyStateInputEntryByRoleName<TKey extends string = MutableToolStepKey> = Partial<Record<RoleName, MutableStrategyStateInputEntry<TKey>>>;
+export type MutableStrategyState<TKey extends string = MutableToolStepKey> = Partial<Record<TKey, MutableStrategyStateInputEntryByRoleName<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'> & {
+    macroStepKey: MutableBranchStepKey;
+    cases: [MutableCase<TKey>, ...MutableCase<TKey>[]];
+};
+export type MutableWhileStep<TKey extends string = MutableToolStepKey> = Omit<WhileStep, 'case'> & {
+    macroStepKey: MutableWhileStepKey;
+    case: MutableCase<TKey>;
+};
+export type MutableForStep<TKey extends string = MutableToolStepKey> = Omit<ForStep, 'case'> & {
+    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 getStrategyStateInputEntryByRoleName<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepKey: TKey): MutableStrategyStateInputEntryByRoleName<TKey> | undefined;
+export declare function getStrategyStateInputEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress<TKey>): MutableStrategyStateInputEntry<TKey> | undefined;
+export declare function setStrategyStateInputEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress<TKey>, entry: MutableStrategyStateInputEntry<TKey>): TStrategyState;
+export declare function clearInputBinding<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress<TKey>): TStrategyState;
+export declare function bindInputResource<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>>;
+    toolMap: ReadonlyMap<ToolHandle, Tool>;
+}): TStrategyState;
+export declare function bindExternalInputPotential<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, target: MutableToolStepRoleAddress<TKey>): TStrategyState;

package/dist/utils/mutableStrategyOverlay.js

@@ -0,0 +1,115 @@
+import { extractResourceTypeHandleFromRoleValue } from './strategyExtraction.js';
+export function getAuthoringSteps(strategy) {
+    return strategy.stepsByThreadIndex[0] ?? [];
+}
+export function setAuthoringSteps(strategy, steps) {
+    const nextStepsByThreadIndex = [...strategy.stepsByThreadIndex];
+    nextStepsByThreadIndex[0] = steps;
+    return {
+        ...strategy,
+        stepsByThreadIndex: nextStepsByThreadIndex,
+    };
+}
+export function getStrategyStateInputEntryByRoleName(strategyState, toolStepKey) {
+    return strategyState[toolStepKey];
+}
+export function getStrategyStateInputEntry(strategyState, toolStepRoleAddress) {
+    const inputEntryByRoleName = getStrategyStateInputEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey);
+    return inputEntryByRoleName?.[toolStepRoleAddress.roleName];
+}
+export function setStrategyStateInputEntry(strategyState, toolStepRoleAddress, entry) {
+    const inputEntryByRoleName = getStrategyStateInputEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey) ?? {};
+    return {
+        ...strategyState,
+        [toolStepRoleAddress.toolStepKey]: {
+            ...inputEntryByRoleName,
+            [toolStepRoleAddress.roleName]: entry,
+        },
+    };
+}
+export function clearInputBinding(strategyState, toolStepRoleAddress) {
+    const inputEntryByRoleName = getStrategyStateInputEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey);
+    if (!inputEntryByRoleName || !(toolStepRoleAddress.roleName in inputEntryByRoleName)) {
+        return strategyState;
+    }
+    const nextInputEntryByRoleName = { ...inputEntryByRoleName };
+    delete nextInputEntryByRoleName[toolStepRoleAddress.roleName];
+    if (Object.keys(nextInputEntryByRoleName).length === 0) {
+        const nextStrategyState = { ...strategyState };
+        delete nextStrategyState[toolStepRoleAddress.toolStepKey];
+        return nextStrategyState;
+    }
+    return {
+        ...strategyState,
+        [toolStepRoleAddress.toolStepKey]: nextInputEntryByRoleName,
+    };
+}
+export function bindInputResource(strategyState, target, resource) {
+    const mutableInputResource = {
+        ...resource,
+        strategyStateInputKind: 'inputResource',
+    };
+    return setStrategyStateInputEntry(strategyState, target, mutableInputResource);
+}
+function getInputRoleValue(tool, roleName) {
+    return tool.roleSpec.inputRoleValueByName[roleName];
+}
+function getOutputRoleValue(tool, roleName) {
+    return tool.roleSpec.outputRoleValueByName[roleName];
+}
+export function bindInternalInputPotential(strategyState, targetAddress, sourceAddress, context) {
+    const sourceToolStep = context.toolStepByKey.get(sourceAddress.toolStepKey) ?? null;
+    if (!sourceToolStep) {
+        throw new Error(`Source tool step not found for '${sourceAddress.toolStepKey}'.`);
+    }
+    const targetToolStep = context.toolStepByKey.get(targetAddress.toolStepKey) ?? null;
+    if (!targetToolStep) {
+        throw new Error(`Target tool step not found for '${targetAddress.toolStepKey}'.`);
+    }
+    const sourceTool = context.toolMap.get(sourceToolStep.toolHandle) ?? null;
+    if (!sourceTool) {
+        throw new Error(`Source tool not found for '${sourceToolStep.toolHandle}'.`);
+    }
+    const targetTool = context.toolMap.get(targetToolStep.toolHandle) ?? null;
+    if (!targetTool) {
+        throw new Error(`Target tool not found for '${targetToolStep.toolHandle}'.`);
+    }
+    const targetInputRole = getInputRoleValue(targetTool, targetAddress.roleName);
+    if (!targetInputRole) {
+        throw new Error(`Target input role not found for (${targetAddress.toolStepKey}, ${targetAddress.roleName}).`);
+    }
+    const sourceOutputRole = getOutputRoleValue(sourceTool, sourceAddress.roleName);
+    const sourceInputRole = getInputRoleValue(sourceTool, sourceAddress.roleName);
+    const sourceInputEntryByRoleName = strategyState[sourceAddress.toolStepKey];
+    const sourceInputEntry = sourceInputEntryByRoleName?.[sourceAddress.roleName];
+    const sourceRoleType = sourceOutputRole
+        ? extractResourceTypeHandleFromRoleValue(sourceOutputRole)
+        : sourceInputRole
+            ? extractResourceTypeHandleFromRoleValue(sourceInputRole)
+            : null;
+    const targetRoleType = extractResourceTypeHandleFromRoleValue(targetInputRole);
+    if (!sourceOutputRole && sourceInputRole) {
+        if (!sourceInputEntry) {
+            throw new Error(`Source input role is not bound for (${sourceAddress.toolStepKey}, ${sourceAddress.roleName}).`); // ATTENTION: not an ontological invariant, but it might help catch some mistakes early on.
+        }
+    }
+    if (!sourceOutputRole && !sourceInputRole) {
+        throw new Error(`Source role not found for (${sourceAddress.toolStepKey}, ${sourceAddress.roleName}).`);
+    }
+    if (!sourceRoleType || !targetRoleType || sourceRoleType !== targetRoleType) {
+        throw new Error(`Reference type mismatch between source (${sourceAddress.toolStepKey}, ${sourceAddress.roleName}) and target (${targetAddress.toolStepKey}, ${targetAddress.roleName}).`);
+    }
+    return setStrategyStateInputEntry(strategyState, targetAddress, {
+        strategyStateInputKind: 'internalInputPotential',
+        toolStepRoleAddress: {
+            toolStepKey: sourceAddress.toolStepKey,
+            roleName: sourceAddress.roleName,
+        },
+    });
+}
+export function bindExternalInputPotential(strategyState, target) {
+    const mutableExternalInputPotential = {
+        strategyStateInputKind: 'externalInputPotential',
+    };
+    return setStrategyStateInputEntry(strategyState, target, mutableExternalInputPotential);
+}

package/dist/utils/resourceCreation.d.ts

@@ -0,0 +1,11 @@
+import type { ToolStepRoleAddress, ResourceId, Resource, ResourceTypeHandle, StrategyTraceHandle } from '@toolproof-core/genesis';
+export type ResourceCreationDescriptor = {
+    id: ResourceId;
+    resourceTypeHandle: ResourceTypeHandle;
+} | {
+    id: ResourceId;
+    resourceTypeHandle: ResourceTypeHandle;
+    toolStepRoleAddress: ToolStepRoleAddress;
+    strategyTraceHandle: StrategyTraceHandle;
+};
+export declare function createResourceFromDescriptor(descriptor: ResourceCreationDescriptor, projection: unknown): Resource;

package/dist/utils/resourceCreation.js

@@ -0,0 +1,32 @@
+import { CONSTANTS } from '../lookups/lookups.js';
+function createStrategyProvenance(strategyTraceHandle, toolStepRoleAddress) {
+    return {
+        provenanceKind: CONSTANTS.Enums.ProvenanceKind.strategy,
+        strategyTraceHandle,
+        toolStepRoleAddress,
+    };
+}
+function createRuntimeProvenance() {
+    return {
+        provenanceKind: CONSTANTS.Enums.ProvenanceKind.runtime,
+    };
+}
+function createResourcePointer(id, resourceTypeHandle, provenance) {
+    return {
+        id,
+        resourceTypeHandle,
+        provenance,
+    };
+}
+function createResource(resourcePointer, projection) {
+    return {
+        ...resourcePointer,
+        projection,
+    };
+}
+export function createResourceFromDescriptor(descriptor, projection) {
+    const provenance = 'toolStepRoleAddress' in descriptor
+        ? createStrategyProvenance(descriptor.strategyTraceHandle, descriptor.toolStepRoleAddress)
+        : createRuntimeProvenance();
+    return createResource(createResourcePointer(descriptor.id, descriptor.resourceTypeHandle, provenance), projection);
+}

package/dist/utils/stepCreation.d.ts

@@ -0,0 +1,9 @@
+import type { Tool } 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 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;
+export declare function cloneForStep(forStep: MutableForStep): MutableForStep;
+export declare function cloneWhileStep(whileStep: MutableWhileStep): MutableWhileStep;

package/dist/utils/stepCreation.js

@@ -0,0 +1,79 @@
+import { CONSTANTS } from '../lookups/lookups.js';
+import { getInputRoleNamesFromTool, getOutputRoleNamesFromTool } from './strategyExtraction.js';
+import { generateIdentifier } from './identifierGeneration.js';
+function assertNonEmpty(arr, msg) {
+    if (arr.length === 0) {
+        throw new Error(msg);
+    }
+}
+function getRoleBindingSpec(tool) {
+    return {
+        inputBindings: getInputRoleNamesFromTool(tool),
+        outputBindings: getOutputRoleNamesFromTool(tool),
+    };
+}
+export function createToolStepFromTool(tool) {
+    return {
+        toolStepKey: generateIdentifier('ToolStepKey'),
+        stepKind: CONSTANTS.Enums.StepKind.tool,
+        toolHandle: tool.handle,
+        roleBindingSpec: getRoleBindingSpec(tool),
+    };
+}
+export function createCaseFromToolStepPair(what, when) {
+    return { what, when };
+}
+export function createLoopStepFromCase(stepCase, stepKind) {
+    if (stepKind === CONSTANTS.Enums.StepKind.for) {
+        return {
+            macroStepKey: generateIdentifier('ForStepKey'),
+            stepKind: CONSTANTS.Enums.StepKind.for,
+            case: stepCase,
+        };
+    }
+    return {
+        macroStepKey: generateIdentifier('WhileStepKey'),
+        stepKind: CONSTANTS.Enums.StepKind.while,
+        case: stepCase,
+    };
+}
+export function createBranchStepFromCases(cases) {
+    assertNonEmpty(cases, 'createBranchStepFromCases requires at least one case');
+    return {
+        macroStepKey: generateIdentifier('BranchStepKey'),
+        stepKind: CONSTANTS.Enums.StepKind.branch,
+        cases,
+    };
+}
+export function cloneForStep(forStep) {
+    return {
+        macroStepKey: generateIdentifier('ForStepKey'),
+        stepKind: CONSTANTS.Enums.StepKind.for,
+        case: {
+            what: {
+                ...forStep.case.what,
+                toolStepKey: generateIdentifier('ToolStepKey'),
+            },
+            when: {
+                ...forStep.case.when,
+                toolStepKey: generateIdentifier('ToolStepKey'),
+            },
+        },
+    };
+}
+export function cloneWhileStep(whileStep) {
+    return {
+        macroStepKey: generateIdentifier('WhileStepKey'),
+        stepKind: CONSTANTS.Enums.StepKind.while,
+        case: {
+            what: {
+                ...whileStep.case.what,
+                toolStepKey: generateIdentifier('ToolStepKey'),
+            },
+            when: {
+                ...whileStep.case.when,
+                toolStepKey: generateIdentifier('ToolStepKey'),
+            },
+        },
+    };
+}

package/dist/utils/stepParallelization.d.ts

@@ -0,0 +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[][];