@toolproof-core/lib 1.0.13 → 1.0.15

package/dist/utils/creation/stepCreation.js

@@ -0,0 +1,89 @@
+import { CONSTANTS } from '../../artifacts/artifacts.js';
+function assertNonEmpty(arr, msg) {
+    if (arr.length === 0) {
+        throw new Error(msg);
+    }
+}
+function getRoleBindings(job) {
+    return {
+        inputBindings: Object.keys(job.roles.inputDict),
+        outputBindings: Object.keys(job.roles.outputDict),
+    };
+}
+export function buildJobStepFromJob(job, identity) {
+    return {
+        identity,
+        stepKind: CONSTANTS.Enums.StepKind.job,
+        jobHandle: job.identity,
+        roleBindings: getRoleBindings(job),
+    };
+}
+export function buildLoopStepFromJobPair(whatJob, whenJob, identities) {
+    const what = buildJobStepFromJob(whatJob, identities.whatIdentity);
+    const when = buildJobStepFromJob(whenJob, identities.whenIdentity);
+    if (identities.stepKind === CONSTANTS.Enums.StepKind.for) {
+        return {
+            identity: identities.stepIdentity,
+            stepKind: CONSTANTS.Enums.StepKind.for,
+            case: { what, when },
+        };
+    }
+    return {
+        identity: identities.stepIdentity,
+        stepKind: CONSTANTS.Enums.StepKind.while,
+        case: { what, when },
+    };
+}
+export function buildBranchStepFromJobPairs(cases, branchIdentity, caseIdentities) {
+    if (cases.length !== caseIdentities.length) {
+        throw new Error('buildBranchStepFromJobPairs requires one identity pair per case');
+    }
+    const resolved = cases.map(({ whatJob, whenJob }, index) => {
+        const identities = caseIdentities[index];
+        if (!identities) {
+            throw new Error(`Missing case identities for case index ${index}`);
+        }
+        const what = buildJobStepFromJob(whatJob, identities.whatIdentity);
+        const when = buildJobStepFromJob(whenJob, identities.whenIdentity);
+        return { what, when };
+    });
+    assertNonEmpty(resolved, 'buildBranchStepFromJobPairs requires at least one case');
+    return {
+        identity: branchIdentity,
+        stepKind: CONSTANTS.Enums.StepKind.branch,
+        cases: resolved,
+    };
+}
+export function cloneForStepWithIdentities(forStep, identities) {
+    return {
+        identity: identities.stepIdentity,
+        stepKind: CONSTANTS.Enums.StepKind.for,
+        case: {
+            what: {
+                ...forStep.case.what,
+                identity: identities.whatIdentity,
+            },
+            when: {
+                ...forStep.case.when,
+                identity: identities.whenIdentity,
+            },
+        },
+    };
+}
+export function cloneWhileStepWithIdentities(whileStep, identities) {
+    return {
+        identity: identities.stepIdentity,
+        stepKind: CONSTANTS.Enums.StepKind.while,
+        case: {
+            what: {
+                ...whileStep.case.what,
+                identity: identities.whatIdentity,
+            },
+            when: {
+                ...whileStep.case.when,
+                identity: identities.whenIdentity,
+            },
+        },
+    };
+}
+//# sourceMappingURL=stepCreation.js.map

package/dist/utils/creation/stepCreation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stepCreation.js","sourceRoot":"","sources":["../../../src/utils/creation/stepCreation.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-core/lib",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "",
   "type": "module",
   "keywords": [],
@@ -20,16 +20,16 @@
       "import": "./dist/utils/extractData.js"
     },
     "./create-resource": {
-      "types": "./dist/utils/createResource.d.ts",
-      "import": "./dist/utils/createResource.js"
+      "types": "./dist/utils/creation/resourceCreation.d.ts",
+      "import": "./dist/utils/creation/resourceCreation.js"
     },
     "./create-step": {
-      "types": "./dist/utils/createStep.d.ts",
-      "import": "./dist/utils/createStep.js"
+      "types": "./dist/integrations/firebase/createStep.d.ts",
+      "import": "./dist/integrations/firebase/createStep.js"
     },
     "./create-runnable-strategy": {
-      "types": "./dist/utils/createRunnableStrategy.d.ts",
-      "import": "./dist/utils/createRunnableStrategy.js"
+      "types": "./dist/integrations/firebase/createRunnableStrategy.d.ts",
+      "import": "./dist/integrations/firebase/createRunnableStrategy.js"
     },
     "./resolve-resource-chain": {
       "types": "./dist/utils/resolveResourceChain.d.ts",
@@ -40,19 +40,19 @@
       "import": "./dist/utils/bindInputRoleToResource.js"
     },
     "./firebase-admin-init": {
-      "types": "./dist/_lib/setup/firebaseAdminInit.d.ts",
-      "import": "./dist/_lib/setup/firebaseAdminInit.js"
+      "types": "./dist/integrations/firebase/firebaseAdminInit.d.ts",
+      "import": "./dist/integrations/firebase/firebaseAdminInit.js"
     },
     "./firebase-admin-helpers": {
-      "types": "./dist/firebase/firebaseAdminHelpers.d.ts",
-      "import": "./dist/firebase/firebaseAdminHelpers.js"
+      "types": "./dist/integrations/firebase/firebaseAdminHelpers.d.ts",
+      "import": "./dist/integrations/firebase/firebaseAdminHelpers.js"
     }
   },
   "devDependencies": {
     "@types/node": "^22.0.0"
   },
   "dependencies": {
-    "@toolproof-core/schema": "^1.0.21",
+    "@toolproof-core/schema": "^1.0.23",
     "firebase-admin": "^13.7.0"
   },
   "scripts": {

package/src/integrations/firebase/createRunnableStrategy.ts

@@ -0,0 +1,20 @@
+import type { RawStrategyJson, RunnableStrategyJson } from '@toolproof-core/schema';
+import { CONSTANTS } from '../../artifacts/artifacts.js';
+import {
+    buildRunnableStrategy,
+    getRunnableStrategyThreadGroups,
+} from '../../utils/creation/runnableStrategyCreation.js';
+import { getNewIdentity } from './firebaseAdminHelpers.js';
+
+export function createRunnableStrategy(rawStrategy: RawStrategyJson): RunnableStrategyJson {
+    const threadStepGroups = getRunnableStrategyThreadGroups(rawStrategy);
+    const runnableStrategyIdentity = getNewIdentity(CONSTANTS.Names.RunnableStrategyIdentity);
+    const threadIdentities = threadStepGroups.map(() => getNewIdentity(CONSTANTS.Names.StrategyThreadIdentity));
+
+    return buildRunnableStrategy(
+        rawStrategy,
+        runnableStrategyIdentity,
+        threadStepGroups,
+        threadIdentities,
+    );
+}

package/src/integrations/firebase/createStep.ts

@@ -0,0 +1,71 @@
+import type {
+    BranchStepJson,
+    ForStepJson,
+    JobJson,
+    JobStepJson,
+    WhileStepJson,
+} from '@toolproof-core/schema';
+import { CONSTANTS } from '../../artifacts/artifacts.js';
+import {
+    buildBranchStepFromJobPairs,
+    buildJobStepFromJob,
+    buildLoopStepFromJobPair,
+    cloneForStepWithIdentities,
+    cloneWhileStepWithIdentities,
+} from '../../utils/creation/stepCreation.js';
+import { getNewStepIdentity } from './firebaseAdminHelpers.js';
+
+export function createJobStepFromJob(job: JobJson): JobStepJson {
+    return buildJobStepFromJob(job, getNewStepIdentity(CONSTANTS.Enums.StepKind.job));
+}
+
+export function createLoopStepFromJobPair(
+    whatJob: JobJson,
+    whenJob: JobJson,
+    stepKind: typeof CONSTANTS.Enums.StepKind.for | typeof CONSTANTS.Enums.StepKind.while,
+): ForStepJson | WhileStepJson {
+    if (stepKind === CONSTANTS.Enums.StepKind.for) {
+        return buildLoopStepFromJobPair(whatJob, whenJob, {
+            stepKind,
+            stepIdentity: getNewStepIdentity(CONSTANTS.Enums.StepKind.for),
+            whatIdentity: getNewStepIdentity(CONSTANTS.Enums.StepKind.job),
+            whenIdentity: getNewStepIdentity(CONSTANTS.Enums.StepKind.job),
+        });
+    }
+
+    return buildLoopStepFromJobPair(whatJob, whenJob, {
+        stepKind,
+        stepIdentity: getNewStepIdentity(CONSTANTS.Enums.StepKind.while),
+        whatIdentity: getNewStepIdentity(CONSTANTS.Enums.StepKind.job),
+        whenIdentity: getNewStepIdentity(CONSTANTS.Enums.StepKind.job),
+    });
+}
+
+export function createBranchStepFromJobPairs(
+    cases: Array<{ whatJob: JobJson; whenJob: JobJson }>,
+): BranchStepJson {
+    return buildBranchStepFromJobPairs(
+        cases,
+        getNewStepIdentity(CONSTANTS.Enums.StepKind.branch),
+        cases.map(() => ({
+            whatIdentity: getNewStepIdentity(CONSTANTS.Enums.StepKind.job),
+            whenIdentity: getNewStepIdentity(CONSTANTS.Enums.StepKind.job),
+        })),
+    );
+}
+
+export function cloneForStep(forStep: ForStepJson): ForStepJson {
+    return cloneForStepWithIdentities(forStep, {
+        stepIdentity: getNewStepIdentity(CONSTANTS.Enums.StepKind.for),
+        whatIdentity: getNewStepIdentity(CONSTANTS.Enums.StepKind.job),
+        whenIdentity: getNewStepIdentity(CONSTANTS.Enums.StepKind.job),
+    });
+}
+
+export function cloneWhileStep(whileStep: WhileStepJson): WhileStepJson {
+    return cloneWhileStepWithIdentities(whileStep, {
+        stepIdentity: getNewStepIdentity(CONSTANTS.Enums.StepKind.while),
+        whatIdentity: getNewStepIdentity(CONSTANTS.Enums.StepKind.job),
+        whenIdentity: getNewStepIdentity(CONSTANTS.Enums.StepKind.job),
+    });
+}

package/src/{firebase → integrations/firebase}/firebaseAdminHelpers.ts

@@ -3,14 +3,20 @@ import type {
     ResourceTypeIdentityJson,
     StepKindJson,
 } from '@toolproof-core/schema';
-import type { IdentityName, IdentityStringByIdentityName, StepIdentityStringByStepKind, ResourcesByTypeDict } from '../types/types.js';
-import { CONSTANTS } from '../artifacts/artifacts.js';
-import { MAPPINGS } from '../artifacts/artifacts.js';
-import { dbAdmin, storageAdmin } from "../_lib/setup/firebaseAdminInit.js";
-
+import type {
+    IdentityName,
+    IdentityStringByIdentityName,
+    ResourcesByTypeDict,
+    StepIdentityStringByStepKind,
+} from '../../types/types.js';
+import { CONSTANTS, MAPPINGS } from '../../artifacts/artifacts.js';
+import { dbAdmin, storageAdmin } from './firebaseAdminInit.js';
 
 function capitalizeFirst(value: string): string {
-    if (!value) return value;
+    if (!value) {
+        return value;
+    }
+
     return value.charAt(0).toUpperCase() + value.slice(1);
 }
 
@@ -21,35 +27,43 @@ export function getNewIdentity<K extends IdentityName>(identityName: K): Identit
         .doc(identityName)
         .collection(CONSTANTS.Persistence.Collections.members)
         .doc();
+
     return (prefix + docRef.id) as IdentityStringByIdentityName<K>;
 }
 
 export function getNewStepIdentity<K extends StepKindJson>(stepKind: K): StepIdentityStringByStepKind<K> {
     const identityName = `${capitalizeFirst(stepKind)}StepIdentity` as IdentityName;
+
     if (!(identityName in MAPPINGS.IdentityNameToIdentityPrefix)) {
         throw new Error(`No IdentityNameToIdentityPrefix entry for derived step identity name: ${identityName}`);
     }
+
     return getNewIdentity(identityName) as StepIdentityStringByStepKind<K>;
 }
 
 export async function listResources(
-    resourceTypeHandles: ResourceTypeIdentityJson[]
+    resourceTypeHandles: ResourceTypeIdentityJson[],
 ): Promise<ResourcesByTypeDict> {
-    const bucket_resources = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_resources);
-    const bucket_strategies = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_strategies);
+    const bucketResources = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_resources);
+    const bucketStrategies = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_strategies);
 
-    async function fetchFilesUnder(resourceTypeHandle: ResourceTypeIdentityJson): Promise<Array<{ data: unknown; meta: any; name: string }>> {
+    async function fetchFilesUnder(
+        resourceTypeHandle: ResourceTypeIdentityJson,
+    ): Promise<Array<{ data: unknown; meta: any; name: string }>> {
         const bucket = resourceTypeHandle === CONSTANTS.Cosmos.TYPE_RunnableStrategy
-            ? bucket_strategies
-            : bucket_resources;
+            ? bucketStrategies
+            : bucketResources;
         const prefix = `${resourceTypeHandle}/`;
         const [found] = await bucket.getFiles({ prefix });
-        const files = found.filter(f => {
-            const name = f.name || '';
-            if (!name || name.endsWith('/')) return false;
-            return true;
+        const files = found.filter((file) => {
+            const name = file.name || '';
+            return !!name && !name.endsWith('/');
         });
-        if (!files.length) return [];
+
+        if (!files.length) {
+            return [];
+        }
+
         const items = await Promise.all(files.map(async (file) => {
             try {
                 const [buf] = await file.download();
@@ -60,6 +74,7 @@ export async function listResources(
                 return null as unknown as { data: unknown; meta: any; name: string };
             }
         }));
+
         return items.filter(Boolean) as Array<{ data: unknown; meta: any; name: string }>;
     }
 
@@ -68,47 +83,70 @@ export async function listResources(
             const rows = await fetchFilesUnder(resourceTypeHandle);
             const items: ResourceJson[] = rows.map(({ data, meta, name }) => {
                 const flat = meta?.metadata ?? {};
-                // Reconstruct nested object from flattened keys (dot and array index notation)
                 const root: any = {};
-                for (const [k, vRaw] of Object.entries(flat)) {
-                    if (typeof vRaw !== 'string') continue; // GCS should store only strings
-                    const vStr = vRaw.trim();
-                    // Attempt JSON parse for non-simple primitives
-                    let value: any = vStr;
-                    if ((vStr.startsWith('{') && vStr.endsWith('}')) || (vStr.startsWith('[') && vStr.endsWith(']'))) {
-                        try { value = JSON.parse(vStr); } catch { value = vStr; }
+
+                for (const [key, valueRaw] of Object.entries(flat)) {
+                    if (typeof valueRaw !== 'string') {
+                        continue;
+                    }
+
+                    const valueString = valueRaw.trim();
+                    let value: any = valueString;
+
+                    if ((valueString.startsWith('{') && valueString.endsWith('}')) || (valueString.startsWith('[') && valueString.endsWith(']'))) {
+                        try {
+                            value = JSON.parse(valueString);
+                        } catch {
+                            value = valueString;
+                        }
                     }
-                    // Split by '.' while preserving array indices
-                    const segments = k.split('.');
+
+                    const segments = key.split('.');
                     let cursor = root;
-                    for (const [i, seg] of segments.entries()) {
-                        const arrIdxMatch = seg.match(/^(.*)\[(\d+)\]$/);
+
+                    for (const [index, segment] of segments.entries()) {
+                        const arrIdxMatch = segment.match(/^(.*)\[(\d+)\]$/);
+
                         if (arrIdxMatch) {
                             const base = arrIdxMatch[1];
                             const idxStr = arrIdxMatch[2];
-                            if (base === undefined || idxStr === undefined) continue;
+
+                            if (base === undefined || idxStr === undefined) {
+                                continue;
+                            }
+
                             const idx = parseInt(idxStr, 10);
-                            if (!cursor[base]) cursor[base] = [];
-                            if (!Array.isArray(cursor[base])) cursor[base] = [];
-                            while (cursor[base].length <= idx) cursor[base].push(undefined);
-                            if (i === segments.length - 1) {
+
+                            if (!cursor[base] || !Array.isArray(cursor[base])) {
+                                cursor[base] = [];
+                            }
+
+                            while (cursor[base].length <= idx) {
+                                cursor[base].push(undefined);
+                            }
+
+                            if (index === segments.length - 1) {
                                 cursor[base][idx] = value;
                             } else {
-                                if (!cursor[base][idx]) cursor[base][idx] = {};
+                                if (!cursor[base][idx]) {
+                                    cursor[base][idx] = {};
+                                }
                                 cursor = cursor[base][idx];
                             }
                         } else {
-                            if (i === segments.length - 1) {
-                                cursor[seg] = value;
+                            if (index === segments.length - 1) {
+                                cursor[segment] = value;
                             } else {
-                                if (!cursor[seg] || typeof cursor[seg] !== 'object') cursor[seg] = {};
-                                cursor = cursor[seg];
+                                if (!cursor[segment] || typeof cursor[segment] !== 'object') {
+                                    cursor[segment] = {};
+                                }
+                                cursor = cursor[segment];
                             }
                         }
                     }
                 }
+
                 const identity = root.identity;
-                // const resourceTypeHandle = root.resourceTypeHandle; // we already have this
                 const resourceRoleHandle = root.creationContext.resourceRoleHandle;
                 const jobStepHandle = root.creationContext.jobStepHandle;
                 const resourceShellKind = root.resourceShellKind;
@@ -116,7 +154,7 @@ export async function listResources(
                 const version = typeof versionRaw === 'number'
                     ? versionRaw
                     : parseInt(String(versionRaw ?? ''), 10);
-                const path = root.path;
+                const resourcePath = root.path;
                 const timestamp = root.timestamp;
 
                 const missing = [
@@ -126,11 +164,11 @@ export async function listResources(
                     ['resourceShellKind', resourceShellKind],
                     ['version', Number.isFinite(version) ? String(version) : ''],
                     ['timestamp', timestamp],
-                    ['path', path],
-                ].filter(([_, v]) => typeof v !== 'string' || (v as string).length === 0) as Array<[string, string | undefined]>;
+                    ['path', resourcePath],
+                ].filter(([_, value]) => typeof value !== 'string' || (value as string).length === 0) as Array<[string, string | undefined]>;
 
                 if (missing.length) {
-                    const keys = missing.map(([k]) => k).join(', ');
+                    const keys = missing.map(([key]) => key).join(', ');
                     throw new Error(`Missing required metadata keys [${keys}] for resource file: ${name}`);
                 }
 
@@ -144,14 +182,14 @@ export async function listResources(
                     resourceShellKind,
                     version,
                     timestamp: timestamp as string,
-                    path: path as string,
+                    path: resourcePath as string,
                     nucleus: data as any,
                 } as unknown as ResourceJson;
             });
+
             return [resourceTypeHandle, items] as const;
-        })
+        }),
     );
-    return Object.fromEntries(entries) as ResourcesByTypeDict;
-}
-
 
+    return Object.fromEntries(entries) as ResourcesByTypeDict;
+}

package/src/integrations/firebase/firebaseAdminInit.ts

@@ -0,0 +1,39 @@
+import { getApp, getApps, initializeApp, applicationDefault, cert } from 'firebase-admin/app';
+import { getFirestore } from 'firebase-admin/firestore';
+import { getStorage } from 'firebase-admin/storage';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+
+function resolveCredential() {
+    const jsonString = process.env.GOOGLE_APPLICATION_CREDENTIALS_JSON;
+    const envPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
+    const localKeyPath = path.join(process.cwd(), 'gcp-key.json');
+
+    try {
+        if (jsonString) {
+            return cert(JSON.parse(jsonString));
+        }
+
+        if (envPath && existsSync(envPath)) {
+            return cert(JSON.parse(readFileSync(envPath, 'utf8')));
+        }
+
+        if (existsSync(localKeyPath)) {
+            return cert(JSON.parse(readFileSync(localKeyPath, 'utf8')));
+        }
+    } catch {
+        return applicationDefault();
+    }
+
+    return applicationDefault();
+}
+
+const app = getApps().length ? getApp() : initializeApp({
+    credential: resolveCredential(),
+    projectId: 'toolproof-563fe',
+});
+
+const dbAdmin = getFirestore(app);
+const storageAdmin = getStorage(app);
+
+export { dbAdmin, storageAdmin };

package/src/types/types.ts

@@ -1,7 +1,7 @@
 import type {
-	StepKindJson,
-	ResourceJson,
-	ResourceTypeIdentityJson,
+    StepKindJson,
+    ResourceJson,
+    ResourceTypeIdentityJson,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../artifacts/artifacts.js';
 import { MAPPINGS } from '../artifacts/artifacts.js';
@@ -20,11 +20,11 @@ export type IdentityStringByIdentityName<K extends IdentityName> = `${(typeof MA
 
 export type StepIdentityStringByStepKind<K extends StepKindJson> = `${(typeof MAPPINGS.StepKindToStepIdentityPrefix)[K]}${string}`;
 
-export interface NucleusBaseSmall {
-    identity: string;
+export interface NucleusBaseSmall<T extends string = string> {
+    identity: T;
 }
 
-export interface NucleusBaseLarge extends NucleusBaseSmall {
+export interface NucleusBaseLarge<T extends string = string> extends NucleusBaseSmall<T> {
     name: string;
     description: string;
 }

package/src/utils/{createResource.ts → creation/resourceCreation.ts}

@@ -7,8 +7,7 @@ import type {
     ResourceOutputPotentialJson,
     ResourceTypeIdentityJson,
 } from '@toolproof-core/schema';
-import { CONSTANTS } from '../artifacts/artifacts.js';
-
+import { CONSTANTS } from '../../artifacts/artifacts.js';
 
 export function generatePath(resourceTypeHandle: ResourceTypeIdentityJson, identity: ResourceIdentityJson): string {
     return `${resourceTypeHandle}/${identity}.json`;
@@ -17,10 +16,9 @@ export function generatePath(resourceTypeHandle: ResourceTypeIdentityJson, ident
 export function createMaterializedFromOutputPotential(
     outputPotential: ResourceOutputPotentialJson,
     nucleus: unknown,
-    timestamp?: string
+    timestamp?: string,
 ): ResourceJson {
     const { identity, resourceTypeHandle, creationContext } = outputPotential;
-
     const path = generatePath(resourceTypeHandle, identity);
 
     return {
@@ -29,7 +27,7 @@ export function createMaterializedFromOutputPotential(
         creationContext,
         resourceShellKind: CONSTANTS.Enums.ResourceShellKind.materialized,
         version: 1,
-        timestamp: timestamp ?? new Date().toISOString(), // Preserve original timestamp when copying
+        timestamp: timestamp ?? new Date().toISOString(),
         path,
         nucleus,
     };
@@ -38,10 +36,9 @@ export function createMaterializedFromOutputPotential(
 export function createMaterializedFromInputPotential(
     inputPotential: ResourceInputPotentialJson,
     nucleus: unknown,
-    timestamp?: string
+    timestamp?: string,
 ): ResourceJson {
     const { identity, resourceTypeHandle, creationContext } = inputPotential;
-
     const path = generatePath(resourceTypeHandle, identity);
 
     return {
@@ -59,17 +56,18 @@ export function createMaterializedFromInputPotential(
 export function createMaterializedFromPotential(
     potential: ResourceInputPotentialJson | ResourceOutputPotentialJson,
     nucleus: unknown,
-    timestamp?: string
+    timestamp?: string,
 ): ResourceJson {
     if (potential.resourceShellKind === CONSTANTS.Enums.ResourceShellKind.inputPotential) {
         return createMaterializedFromInputPotential(potential, nucleus, timestamp);
     }
+
     return createMaterializedFromOutputPotential(potential, nucleus, timestamp);
 }
 
 export function createMissing(
     identity: ResourceIdentityJson,
-    resourceTypeHandle: ResourceTypeIdentityJson
+    resourceTypeHandle: ResourceTypeIdentityJson,
 ): ResourceMissingJson {
     return {
         identity,
@@ -81,7 +79,7 @@ export function createMissing(
 export function createInputPotential(
     identity: ResourceIdentityJson,
     resourceTypeHandle: ResourceTypeIdentityJson,
-    creationContext: CreationContextJson
+    creationContext: CreationContextJson,
 ): ResourceInputPotentialJson {
     return {
         identity,
@@ -94,7 +92,7 @@ export function createInputPotential(
 export function createOutputPotential(
     identity: ResourceIdentityJson,
     resourceTypeHandle: ResourceTypeIdentityJson,
-    creationContext: CreationContextJson
+    creationContext: CreationContextJson,
 ): ResourceOutputPotentialJson {
     return {
         identity,

package/src/utils/creation/runnableStrategyCreation.ts

@@ -0,0 +1,46 @@
+import type {
+    RawStrategyJson,
+    RunnableStrategyIdentityJson,
+    RunnableStrategyJson,
+    StepJson,
+    StrategyThreadDictJson,
+    StrategyThreadIdentityJson,
+} from '@toolproof-core/schema';
+import { CONSTANTS } from '../../artifacts/artifacts.js';
+import { getIndependentThreads } from '../parallelizeSteps.js';
+
+export function getRunnableStrategyThreadGroups(rawStrategy: RawStrategyJson): StepJson[][] {
+    return getIndependentThreads(rawStrategy.steps, rawStrategy.strategyState);
+}
+
+export function buildRunnableStrategy(
+    rawStrategy: RawStrategyJson,
+    runnableStrategyIdentity: RunnableStrategyIdentityJson,
+    threadStepGroups: StepJson[][],
+    threadIdentities: StrategyThreadIdentityJson[],
+): RunnableStrategyJson {
+    if (threadStepGroups.length !== threadIdentities.length) {
+        throw new Error('buildRunnableStrategy requires one thread identity per thread group');
+    }
+
+    const strategyThreadDict: StrategyThreadDictJson = {};
+
+    for (const [index, group] of threadStepGroups.entries()) {
+        const threadIdentity = threadIdentities[index];
+
+        if (!threadIdentity) {
+            throw new Error(`Missing thread identity for thread group index ${index}`);
+        }
+
+        strategyThreadDict[threadIdentity] = group;
+    }
+
+    return {
+        identity: runnableStrategyIdentity,
+        runnableStrategyContext: {
+            status: CONSTANTS.Enums.RunnableStrategyStatus.pending,
+        },
+        strategyThreadDict,
+        strategyState: rawStrategy.strategyState,
+    };
+}