@toolproof-core/lib 1.0.32 → 1.0.34

package/dist/utils/strategyState.js

@@ -0,0 +1,29 @@
+export function getStrategyStateBucket(strategyState, toolStepPath) {
+    return strategyState[toolStepPath];
+}
+export function getStrategyStateEntry(strategyState, context) {
+    return getStrategyStateBucket(strategyState, context.toolStepPath)?.[context.roleName];
+}
+export function setStrategyStateEntry(strategyState, context, entry) {
+    const bucket = getStrategyStateBucket(strategyState, context.toolStepPath) ?? {};
+    return {
+        ...strategyState,
+        [context.toolStepPath]: {
+            ...bucket,
+            [context.roleName]: entry,
+        },
+    };
+}
+export function clearStrategyStateEntry(strategyState, context) {
+    const bucket = getStrategyStateBucket(strategyState, context.toolStepPath);
+    if (!bucket || !(context.roleName in bucket)) {
+        return strategyState;
+    }
+    const nextBucket = { ...bucket };
+    delete nextBucket[context.roleName];
+    return {
+        ...strategyState,
+        [context.toolStepPath]: nextBucket,
+    };
+}
+//# sourceMappingURL=strategyState.js.map

package/dist/utils/strategyState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategyState.js","sourceRoot":"","sources":["../../src/utils/strategyState.ts"],"names":[],"mappings":"AAUA,MAAM,UAAU,sBAAsB,CAClC,aAAgC,EAChC,YAA6C;IAE7C,OAAO,aAAa,CAAC,YAAY,CAAkD,CAAC;AACxF,CAAC;AAED,MAAM,UAAU,qBAAqB,CACjC,aAAgC,EAChC,OAAwB;IAExB,OAAO,sBAAsB,CAAC,aAAa,EAAE,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC3F,CAAC;AAED,MAAM,UAAU,qBAAqB,CACjC,aAA6B,EAC7B,OAAwB,EACxB,KAA8B;IAE9B,MAAM,MAAM,GAAG,sBAAsB,CAAC,aAAa,EAAE,OAAO,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;IAEjF,OAAO;QACH,GAAG,aAAa;QAChB,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE;YACpB,GAAG,MAAM;YACT,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,KAAK;SAC5B;KACc,CAAC;AACxB,CAAC;AAED,MAAM,UAAU,uBAAuB,CACnC,aAA6B,EAC7B,OAAwB;IAExB,MAAM,MAAM,GAAG,sBAAsB,CAAC,aAAa,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;IAC3E,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC,OAAO,CAAC,QAAQ,IAAI,MAAM,CAAC,EAAE,CAAC;QAC3C,OAAO,aAAa,CAAC;IACzB,CAAC;IAED,MAAM,UAAU,GAAG,EAAE,GAAG,MAAM,EAAE,CAAC;IACjC,OAAO,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAEpC,OAAO;QACH,GAAG,aAAa;QAChB,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,UAAU;KACnB,CAAC;AACxB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-core/lib",
-  "version": "1.0.32",
+  "version": "1.0.34",
   "description": "",
   "type": "module",
   "keywords": [],
@@ -27,9 +27,9 @@
       "types": "./dist/integrations/firebase/createStep.d.ts",
       "import": "./dist/integrations/firebase/createStep.js"
     },
-    "./create-runnable-strategy": {
-      "types": "./dist/integrations/firebase/createRunnableStrategy.d.ts",
-      "import": "./dist/integrations/firebase/createRunnableStrategy.js"
+    "./create-threaded-strategy": {
+      "types": "./dist/integrations/firebase/createThreadedStrategy.d.ts",
+      "import": "./dist/integrations/firebase/createThreadedStrategy.js"
     },
     "./resolve-resource-chain": {
       "types": "./dist/utils/resolveResourceChain.d.ts",
@@ -52,11 +52,11 @@
     "@types/node": "^22.0.0"
   },
   "dependencies": {
-    "@toolproof-core/schema": "^1.0.44",
+    "@toolproof-core/schema": "^1.0.46",
     "firebase-admin": "^13.7.0"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "tsc -b"
+    "build": "if exist dist rmdir /s /q dist && if exist tsconfig.tsbuildinfo del /q tsconfig.tsbuildinfo && tsc -b"
   }
 }

package/src/artifacts/artifacts.ts

@@ -24,8 +24,8 @@ export const CONSTANTS = {
         TYPE_ResourceType: 'TYPE-ResourceType',
         TYPE_Tool: 'TYPE-Tool',
         TYPE_Error: 'TYPE-Error',
-        TYPE_RawStrategy: 'TYPE-RawStrategy',
-        TYPE_RunnableStrategy: 'TYPE-RunnableStrategy',
+        TYPE_UnthreadedStrategy: 'TYPE-UnthreadedStrategy',
+        TYPE_ThreadedStrategy: 'TYPE-ThreadedStrategy',
         TYPE_StrategyRun: 'TYPE-StrategyRun',
         ROLE_Manual: 'ROLE-Manual',
         ROLE_ErrorOutput: 'ROLE-ErrorOutput',

package/src/integrations/firebase/createThreadedStrategy.ts

@@ -0,0 +1,19 @@
+import { CONSTANTS } from '../../artifacts/artifacts.js';
+import {
+    buildThreadedStrategy,
+    getThreadedStrategyStepGroups,
+    type ThreadableStrategy,
+    type ThreadedStrategyLike,
+} from '../../utils/creation/threadedStrategyCreation.js';
+import { getNewId } from './firebaseAdminHelpers.js';
+
+export function createThreadedStrategy<TStrategyState>(strategy: ThreadableStrategy<TStrategyState>): ThreadedStrategyLike<TStrategyState> {
+    const threadStepGroups = getThreadedStrategyStepGroups(strategy);
+    const strategyId = getNewId(CONSTANTS.Names.StrategyId);
+
+    return buildThreadedStrategy(
+        threadStepGroups,
+        strategyId,
+        strategy,
+    );
+}

package/src/integrations/firebase/firebaseAdminHelpers.ts

@@ -1,5 +1,7 @@
 import type {
+    CreationContext,
     Resource,
+    ResourceProvenance,
     ResourceTypeId,
     StepKind,
 } from '@toolproof-core/schema';
@@ -7,11 +9,12 @@ import type {
     IdName,
     IdStringByIdName,
     ResourcesByType,
-    StepIdStringByStepKind,
 } from '../../types/types.js';
 import { CONSTANTS, MAPPINGS } from '../../artifacts/artifacts.js';
 import { dbAdmin, storageAdmin } from './firebaseAdminInit.js';
 
+type StepIdStringByStepKind<K extends StepKind> = string & { readonly __stepKind?: K };
+
 function capitalizeFirst(value: string): string {
     if (!value) {
         return value;
@@ -50,7 +53,7 @@ export async function listResources(
     async function fetchFilesUnder(
         resourceTypeId: ResourceTypeId,
     ): Promise<Array<{ data: unknown; meta: any; name: string }>> {
-        const bucket = resourceTypeId === CONSTANTS.Cosmos.TYPE_RunnableStrategy
+        const bucket = resourceTypeId === CONSTANTS.Cosmos.TYPE_ThreadedStrategy
             ? bucketStrategies
             : bucketResources;
         const prefix = `${resourceTypeId}/`;
@@ -147,9 +150,7 @@ export async function listResources(
                 }
 
                 const id = root.id;
-                const resourceRoleId = root.creationContext.resourceRoleId;
-                const toolStepId = root.creationContext.toolStepId;
-                const resourceShellKind = root.resourceShellKind;
+                const provenance = root.provenance as ResourceProvenance | undefined;
                 const versionRaw = root.version;
                 const version = typeof versionRaw === 'number'
                     ? versionRaw
@@ -159,9 +160,6 @@ export async function listResources(
 
                 const missing = [
                     ['id', id],
-                    ['resourceRoleId', resourceRoleId],
-                    ['toolStepId', toolStepId],
-                    ['resourceShellKind', resourceShellKind],
                     ['version', Number.isFinite(version) ? String(version) : ''],
                     ['timestamp', timestamp],
                     ['path', resourcePath],
@@ -172,14 +170,26 @@ export async function listResources(
                     throw new Error(`Missing required metadata keys [${keys}] for resource file: ${name}`);
                 }
 
+                if (!provenance || typeof provenance !== 'object' || typeof provenance.resourceProvenanceKind !== 'string') {
+                    throw new Error(`Missing required metadata key [provenance] for resource file: ${name}`);
+                }
+
+                if (provenance.resourceProvenanceKind === 'strategy') {
+                    const creationContext = (provenance as { creationContext?: CreationContext }).creationContext;
+                    if (
+                        !creationContext ||
+                        typeof creationContext !== 'object' ||
+                        typeof creationContext.roleName !== 'string' ||
+                        typeof creationContext.toolStepPath !== 'string'
+                    ) {
+                        throw new Error(`Missing required strategy provenance creationContext for resource file: ${name}`);
+                    }
+                }
+
                 return {
                     id,
                     resourceTypeId,
-                    creationContext: {
-                        resourceRoleId,
-                        toolStepId,
-                    },
-                    resourceShellKind,
+                    provenance,
                     version,
                     timestamp: timestamp as string,
                     path: resourcePath as string,

package/src/types/types.ts

@@ -18,7 +18,7 @@ export type IdName = keyof typeof MAPPINGS.IdNameToIdPrefix;
 
 export type IdStringByIdName<K extends IdName> = `${(typeof MAPPINGS.IdNameToIdPrefix)[K]}${string}`;
 
-export type StepIdStringByStepKind<K extends StepKind> = `${(typeof MAPPINGS.StepKindToStepIdPrefix)[K]}${string}`;
+export type StepIdStringByStepKind<K extends StepKind> = string & { readonly __stepKind?: K };
 
 export interface NucleusBaseSmall<T extends string = string> {
     id: T;

package/src/utils/bindInputRoleToResource.ts

@@ -1,110 +1,54 @@
 import type {
     CreationContext,
-    ExternalInputPotentialShell,
-    InternalInputPotentialShell,
-    OutputPotentialShell,
     Resource,
-    ResourcePotential,
-    StrategyState,
+    ReferenceInput,
+    ValueInput,
 } from '@toolproof-core/schema';
-import { CONSTANTS } from '../artifacts/artifacts.js';
-import { resolveResourceChain } from './resolveResourceChain.js';
+import {
+    clearStrategyStateEntry,
+    getStrategyStateEntry,
+    setStrategyStateEntry,
+    type StrategyState,
+    type StrategyStateLike,
+} from './strategyState.js';
 
 
-export function bindInputResInStrategyState(
-    strategyState: StrategyState,
+export function bindInputResInStrategyState<TStrategyState extends StrategyStateLike>(
+    strategyState: TStrategyState,
     target: CreationContext,
     resource: Resource
-): StrategyState {
-    const bucket = strategyState[target.toolStepId] ?? {};
-    return {
-        ...strategyState,
-        [target.toolStepId]: {
-            ...bucket,
-            [target.resourceRoleId]: resource,
-        },
+): TStrategyState {
+    const entry: ValueInput = {
+        strategyStateInputKind: 'valueInput',
+        resourceTypeId: resource.resourceTypeId,
+        nucleus: resource.nucleus,
     };
+
+    return setStrategyStateEntry(strategyState, target, entry);
 }
 
-export function bindInputRefInStrategyState(
-    strategyState: StrategyState,
+export function bindInputRefInStrategyState<TStrategyState extends StrategyStateLike>(
+    strategyState: TStrategyState,
     target: CreationContext,
     source: CreationContext
-): StrategyState {
-    const sourceEntry = strategyState?.[source.toolStepId]?.[source.resourceRoleId] as (
-        | Resource
-        | ResourcePotential
-        | undefined
-    );
+): TStrategyState {
+    const sourceEntry = getStrategyStateEntry(strategyState, source);
     if (!sourceEntry) {
-        throw new Error(`resourceEntry not found for source (${source.toolStepId}, ${source.resourceRoleId})`);
-    }
-
-    const result = resolveResourceChain(strategyState, source);
-    const bucket = strategyState[target.toolStepId] ?? {};
-
-    if (result.status === CONSTANTS.Enums.ResourceShellKind.materialized) {
-        return {
-            ...strategyState,
-            [target.toolStepId]: {
-                ...bucket,
-                [target.resourceRoleId]: result.entry,
-            },
-        };
-    }
-
-    if (result.status === CONSTANTS.Enums.ResourceShellKind.externalInputPotential) {
-        const externalInput = result.entry;
-        const reusedExternalInput: ExternalInputPotentialShell = {
-            id: externalInput.id,
-            resourceTypeId: externalInput.resourceTypeId,
-            resourceShellKind: CONSTANTS.Enums.ResourceShellKind.externalInputPotential,
-        };
-
-        return {
-            ...strategyState,
-            [target.toolStepId]: {
-                ...bucket,
-                [target.resourceRoleId]: reusedExternalInput,
-            },
-        };
+        throw new Error(`resourceEntry not found for source (${source.toolStepPath}, ${source.roleName})`);
     }
 
-    if (result.status === CONSTANTS.Enums.ResourceShellKind.outputPotential) {
-        const potentialInput: InternalInputPotentialShell = {
-            id: sourceEntry.id,
-            resourceTypeId: sourceEntry.resourceTypeId,
-            creationContext: {
-                toolStepId: source.toolStepId,
-                resourceRoleId: source.resourceRoleId,
-            },
-            resourceShellKind: CONSTANTS.Enums.ResourceShellKind.internalInputPotential,
-        };
-
-        return {
-            ...strategyState,
-            [target.toolStepId]: {
-                ...bucket,
-                [target.resourceRoleId]: potentialInput,
-            },
-        };
-    }
+    const entry: ReferenceInput = {
+        strategyStateInputKind: 'referenceInput',
+        toolStepPath: source.toolStepPath,
+        roleName: source.roleName,
+    };
 
-    throw new Error(`Failed to resolve resource chain: ${result.reason}`);
+    return setStrategyStateEntry(strategyState, target, entry);
 }
 
-export function clearInputBindingInStrategyState(
-    strategyState: StrategyState,
+export function clearInputBindingInStrategyState<TStrategyState extends StrategyStateLike>(
+    strategyState: TStrategyState,
     target: CreationContext
-): StrategyState {
-    const bucket = strategyState?.[target.toolStepId];
-    if (!bucket?.[target.resourceRoleId]) return strategyState;
-
-    const nextBucket = { ...bucket } as Record<string, unknown>;
-    delete nextBucket[target.resourceRoleId];
-
-    return {
-        ...strategyState,
-        [target.toolStepId]: nextBucket as any,
-    };
+): TStrategyState {
+    return clearStrategyStateEntry(strategyState, target);
 }

package/src/utils/creation/resourceCreation.ts

@@ -1,20 +1,33 @@
 import type {
     CreationContext,
-    ExternalInputPotentialShell,
-    InternalInputPotentialShell,
-    OutputPotentialShell,
+    ExternalInput,
+    ReferenceInput,
     ResourceId,
     Resource,
     ResourceTypeId,
+    StrategyRunId,
 } from '@toolproof-core/schema';
-import { CONSTANTS } from '../../artifacts/artifacts.js';
+
+export interface OutputPotential {
+    id: ResourceId;
+    resourceTypeId: ResourceTypeId;
+    creationContext: CreationContext;
+    strategyRunId?: StrategyRunId;
+}
+
+export type InputPotential = ReferenceInput & {
+    id: ResourceId;
+    resourceTypeId: ResourceTypeId;
+    creationContext: CreationContext;
+    strategyRunId?: StrategyRunId;
+};
 
 export function generatePath(resourceTypeId: ResourceTypeId, id: ResourceId): string {
     return `${resourceTypeId}/${id}.json`;
 }
 
 export function createMaterializedFromOutputPotential(
-    outputPotential: OutputPotentialShell,
+    outputPotential: OutputPotential,
     nucleus: unknown,
     timestamp?: string,
 ): Resource {
@@ -24,8 +37,11 @@ export function createMaterializedFromOutputPotential(
     return {
         id,
         resourceTypeId,
-        creationContext,
-        resourceShellKind: CONSTANTS.Enums.ResourceShellKind.materialized,
+        provenance: {
+            resourceProvenanceKind: 'strategy',
+            strategyRunId: outputPotential.strategyRunId ?? ('STRATEGY_RUN-UNKNOWN' as StrategyRunId),
+            creationContext,
+        },
         version: 1,
         timestamp: timestamp ?? new Date().toISOString(),
         path,
@@ -34,7 +50,7 @@ export function createMaterializedFromOutputPotential(
 }
 
 export function createMaterializedFromInputPotential(
-    inputPotential: InternalInputPotentialShell,
+    inputPotential: InputPotential,
     nucleus: unknown,
     timestamp?: string,
 ): Resource {
@@ -44,8 +60,11 @@ export function createMaterializedFromInputPotential(
     return {
         id,
         resourceTypeId,
-        creationContext,
-        resourceShellKind: CONSTANTS.Enums.ResourceShellKind.materialized,
+        provenance: {
+            resourceProvenanceKind: 'strategy',
+            strategyRunId: inputPotential.strategyRunId ?? ('STRATEGY_RUN-UNKNOWN' as StrategyRunId),
+            creationContext,
+        },
         version: 1,
         timestamp: timestamp ?? new Date().toISOString(),
         path,
@@ -54,11 +73,11 @@ export function createMaterializedFromInputPotential(
 }
 
 export function createMaterializedFromPotential(
-    potential: InternalInputPotentialShell | OutputPotentialShell,
+    potential: InputPotential | OutputPotential,
     nucleus: unknown,
     timestamp?: string,
 ): Resource {
-    if (potential.resourceShellKind === CONSTANTS.Enums.ResourceShellKind.internalInputPotential) {
+    if ('strategyStateInputKind' in potential && potential.strategyStateInputKind === 'referenceInput') {
         return createMaterializedFromInputPotential(potential, nucleus, timestamp);
     }
 
@@ -66,13 +85,11 @@ export function createMaterializedFromPotential(
 }
 
 export function createExternalInputPotential(
-    id: ResourceId,
-    resourceTypeId: ResourceTypeId,
-): ExternalInputPotentialShell {
+    _id: ResourceId,
+    _resourceTypeId: ResourceTypeId,
+): ExternalInput {
     return {
-        id,
-        resourceTypeId,
-        resourceShellKind: CONSTANTS.Enums.ResourceShellKind.externalInputPotential,
+        strategyStateInputKind: 'externalInput',
     };
 }
 
@@ -80,12 +97,14 @@ export function createInputPotential(
     id: ResourceId,
     resourceTypeId: ResourceTypeId,
     creationContext: CreationContext,
-): InternalInputPotentialShell {
+): InputPotential {
     return {
         id,
         resourceTypeId,
+        strategyStateInputKind: 'referenceInput',
+        toolStepPath: creationContext.toolStepPath,
+        roleName: creationContext.roleName,
         creationContext,
-        resourceShellKind: CONSTANTS.Enums.ResourceShellKind.internalInputPotential,
     };
 }
 
@@ -93,11 +112,10 @@ export function createOutputPotential(
     id: ResourceId,
     resourceTypeId: ResourceTypeId,
     creationContext: CreationContext,
-): OutputPotentialShell {
+): OutputPotential {
     return {
         id,
         resourceTypeId,
         creationContext,
-        resourceShellKind: CONSTANTS.Enums.ResourceShellKind.outputPotential,
     };
 }

package/src/utils/creation/stepCreation.ts

@@ -1,17 +1,23 @@
 import type {
-    BranchStepId,
     BranchStep,
     Case,
-    ForStepId,
     ForStep,
     Tool,
-    ToolStepId,
     ToolStep,
-    ResourceRoleId,
-    WhileStepId,
     WhileStep,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../../artifacts/artifacts.js';
+import { getInputRoleNames, getOutputRoleNames } from '../roleSpec.js';
+
+type ToolStepId = string;
+type BranchStepId = string;
+type ForStepId = string;
+type WhileStepId = string;
+
+type ToolStepWithId = ToolStep & { id: ToolStepId };
+type BranchStepWithId = BranchStep & { id: BranchStepId };
+type ForStepWithId = ForStep & { id: ForStepId };
+type WhileStepWithId = WhileStep & { id: WhileStepId };
 
 export type LoopStepBuildIdentities =
     | {
@@ -40,21 +46,21 @@ function assertNonEmpty<T>(arr: T[], msg: string): asserts arr is [T, ...T[]] {
 
 function getRoleBindingSpec(tool: Tool): ToolStep['roleBindingSpec'] {
     return {
-        inputBindings: Object.keys(tool.roleSpec.inputRoleValueById) as ResourceRoleId[],
-        outputBindings: Object.keys(tool.roleSpec.outputRoleValueById) as ResourceRoleId[],
+        inputBindings: getInputRoleNames(tool),
+        outputBindings: getOutputRoleNames(tool),
     };
 }
 
 export function buildToolStepFromTool(
     tool: Tool,
     id: ToolStepId,
-): ToolStep {
+): ToolStepWithId {
     return {
         id,
         stepKind: CONSTANTS.Enums.StepKind.tool,
         toolId: tool.id,
         roleBindingSpec: getRoleBindingSpec(tool),
-    };
+    } as ToolStepWithId;
 }
 
 export function buildLoopStepFromToolPair(
@@ -70,21 +76,21 @@ export function buildLoopStepFromToolPair(
             id: identities.stepId,
             stepKind: CONSTANTS.Enums.StepKind.for,
             case: { what, when },
-        };
+        } as ForStepWithId;
     }
 
     return {
         id: identities.stepId,
         stepKind: CONSTANTS.Enums.StepKind.while,
         case: { what, when },
-    };
+    } as WhileStepWithId;
 }
 
 export function buildBranchStepFromToolPairs(
     cases: Array<{ whatTool: Tool; whenTool: Tool }>,
     branchId: BranchStepId,
     caseIdentities: BranchCaseBuildIdentities[],
-): BranchStep {
+): BranchStepWithId {
     if (cases.length !== caseIdentities.length) {
         throw new Error('buildBranchStepFromToolPairs requires one id pair per case');
     }
@@ -107,7 +113,7 @@ export function buildBranchStepFromToolPairs(
         id: branchId,
         stepKind: CONSTANTS.Enums.StepKind.branch,
         cases: resolved,
-    };
+    } as BranchStepWithId;
 }
 
 export function cloneForStepWithIdentities(
@@ -117,7 +123,7 @@ export function cloneForStepWithIdentities(
         whatId: ToolStepId;
         whenId: ToolStepId;
     },
-): ForStep {
+): ForStepWithId {
     return {
         id: identities.stepId,
         stepKind: CONSTANTS.Enums.StepKind.for,
@@ -131,7 +137,7 @@ export function cloneForStepWithIdentities(
                 id: identities.whenId,
             },
         },
-    };
+    } as ForStepWithId;
 }
 
 export function cloneWhileStepWithIdentities(
@@ -141,7 +147,7 @@ export function cloneWhileStepWithIdentities(
         whatId: ToolStepId;
         whenId: ToolStepId;
     },
-): WhileStep {
+): WhileStepWithId {
     return {
         id: identities.stepId,
         stepKind: CONSTANTS.Enums.StepKind.while,
@@ -155,5 +161,5 @@ export function cloneWhileStepWithIdentities(
                 id: identities.whenId,
             },
         },
-    };
+    } as WhileStepWithId;
 }

package/src/utils/creation/threadedStrategyCreation.ts

@@ -0,0 +1,42 @@
+import type {
+    Step,
+    StrategyId,
+} from '@toolproof-core/schema';
+import { getIndependentThreads } from '../parallelizeSteps.js';
+import { CONSTANTS } from '../../artifacts/artifacts.js';
+
+export type ThreadableStrategy<TStrategyState = unknown> = {
+    id: StrategyId;
+    strategyState: TStrategyState;
+} & (
+    | { steps: Step[] }
+    | { stepsByThreadIndex: Step[][] }
+);
+
+export type ThreadedStrategyLike<TStrategyState = unknown> = {
+    id: StrategyId;
+    strategyKind: typeof CONSTANTS.Enums.StrategyKind.threaded;
+    stepsByThreadIndex: Step[][];
+    strategyState: TStrategyState;
+};
+
+export function getThreadedStrategyStepGroups<TStrategyState>(strategy: ThreadableStrategy<TStrategyState>): Step[][] {
+    if ('steps' in strategy) {
+        return getIndependentThreads(strategy.steps, strategy.strategyState as any);
+    }
+
+    return strategy.stepsByThreadIndex;
+}
+
+export function buildThreadedStrategy<TStrategyState>(
+    threadStepGroups: Step[][],
+    threadedStrategyId: StrategyId,
+    strategy: ThreadableStrategy<TStrategyState>,
+): ThreadedStrategyLike<TStrategyState> {
+    return {
+        id: threadedStrategyId,
+        strategyKind: CONSTANTS.Enums.StrategyKind.threaded,
+        stepsByThreadIndex: threadStepGroups,
+        strategyState: strategy.strategyState,
+    };
+}