@toolproof-core/lib 1.0.31 → 1.0.33

package/dist/utils/strategyState.d.ts

@@ -0,0 +1,7 @@
+import type { CreationContext, Strategy, StrategyStateInputEntry, StrategyStateInputEntryByRoleName } from '@toolproof-core/schema';
+export type StrategyState = Strategy['strategyState'];
+export declare function getStrategyStateBucket(strategyState: StrategyState, toolStepPath: CreationContext['toolStepPath']): StrategyStateInputEntryByRoleName | undefined;
+export declare function getStrategyStateEntry(strategyState: StrategyState, context: CreationContext): StrategyStateInputEntry | undefined;
+export declare function setStrategyStateEntry(strategyState: StrategyState, context: CreationContext, entry: StrategyStateInputEntry): StrategyState;
+export declare function clearStrategyStateEntry(strategyState: StrategyState, context: CreationContext): StrategyState;
+//# sourceMappingURL=strategyState.d.ts.map

package/dist/utils/strategyState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategyState.d.ts","sourceRoot":"","sources":["../../src/utils/strategyState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,eAAe,EACf,QAAQ,EACR,uBAAuB,EACvB,iCAAiC,EACpC,MAAM,wBAAwB,CAAC;AAEhC,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,eAAe,CAAC,CAAC;AAEtD,wBAAgB,sBAAsB,CAClC,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,eAAe,CAAC,cAAc,CAAC,GAC9C,iCAAiC,GAAG,SAAS,CAE/C;AAED,wBAAgB,qBAAqB,CACjC,aAAa,EAAE,aAAa,EAC5B,OAAO,EAAE,eAAe,GACzB,uBAAuB,GAAG,SAAS,CAErC;AAED,wBAAgB,qBAAqB,CACjC,aAAa,EAAE,aAAa,EAC5B,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,uBAAuB,GAC/B,aAAa,CAUf;AAED,wBAAgB,uBAAuB,CACnC,aAAa,EAAE,aAAa,EAC5B,OAAO,EAAE,eAAe,GACzB,aAAa,CAaf"}

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":"AASA,MAAM,UAAU,sBAAsB,CAClC,aAA4B,EAC5B,YAA6C;IAE7C,OAAO,aAAa,CAAC,YAAY,CAAC,CAAC;AACvC,CAAC;AAED,MAAM,UAAU,qBAAqB,CACjC,aAA4B,EAC5B,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,aAA4B,EAC5B,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;KACJ,CAAC;AACN,CAAC;AAED,MAAM,UAAU,uBAAuB,CACnC,aAA4B,EAC5B,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;KACrC,CAAC;AACN,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-core/lib",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "description": "",
   "type": "module",
   "keywords": [],
@@ -52,11 +52,11 @@
     "@types/node": "^22.0.0"
   },
   "dependencies": {
-    "@toolproof-core/schema": "^1.0.42",
+    "@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/integrations/firebase/createRunnableStrategy.ts

@@ -1,4 +1,4 @@
-import type { RawStrategyJson, RunnableStrategyJson } from '@toolproof-core/schema';
+import type { Strategy } from '@toolproof-core/schema';
 import { CONSTANTS } from '../../artifacts/artifacts.js';
 import {
     buildRunnableStrategy,
@@ -6,15 +6,13 @@ import {
 } from '../../utils/creation/runnableStrategyCreation.js';
 import { getNewId } from './firebaseAdminHelpers.js';
 
-export function createRunnableStrategy(rawStrategy: RawStrategyJson): RunnableStrategyJson {
+export function createRunnableStrategy(rawStrategy: Strategy): Strategy {
     const threadStepGroups = getRunnableStrategyThreadGroups(rawStrategy);
-    const runnableStrategyId = getNewId(CONSTANTS.Names.RunnableStrategyId);
-    const threadIdentities = threadStepGroups.map(() => getNewId(CONSTANTS.Names.StrategyThreadId));
+    const strategyId = getNewId(CONSTANTS.Names.StrategyId);
 
     return buildRunnableStrategy(
-        rawStrategy,
-        runnableStrategyId,
         threadStepGroups,
-        threadIdentities,
+        strategyId,
+        rawStrategy,
     );
 }

package/src/integrations/firebase/createStep.ts

@@ -1,9 +1,9 @@
 import type {
-    BranchStepJson,
-    ForStepJson,
-    ToolJson,
-    ToolStepJson,
-    WhileStepJson,
+    BranchStep,
+    ForStep,
+    Tool,
+    ToolStep,
+    WhileStep,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../../artifacts/artifacts.js';
 import {
@@ -15,15 +15,15 @@ import {
 } from '../../utils/creation/stepCreation.js';
 import { getNewStepId } from './firebaseAdminHelpers.js';
 
-export function createToolStepFromTool(tool: ToolJson): ToolStepJson {
+export function createToolStepFromTool(tool: Tool): ToolStep {
     return buildToolStepFromTool(tool, getNewStepId(CONSTANTS.Enums.StepKind.tool));
 }
 
 export function createLoopStepFromToolPair(
-    whatTool: ToolJson,
-    whenTool: ToolJson,
+    whatTool: Tool,
+    whenTool: Tool,
     stepKind: typeof CONSTANTS.Enums.StepKind.for | typeof CONSTANTS.Enums.StepKind.while,
-): ForStepJson | WhileStepJson {
+): ForStep | WhileStep {
     if (stepKind === CONSTANTS.Enums.StepKind.for) {
         return buildLoopStepFromToolPair(whatTool, whenTool, {
             stepKind,
@@ -42,8 +42,8 @@ export function createLoopStepFromToolPair(
 }
 
 export function createBranchStepFromToolPairs(
-    cases: Array<{ whatTool: ToolJson; whenTool: ToolJson }>,
-): BranchStepJson {
+    cases: Array<{ whatTool: Tool; whenTool: Tool }>,
+): BranchStep {
     return buildBranchStepFromToolPairs(
         cases,
         getNewStepId(CONSTANTS.Enums.StepKind.branch),
@@ -54,7 +54,7 @@ export function createBranchStepFromToolPairs(
     );
 }
 
-export function cloneForStep(forStep: ForStepJson): ForStepJson {
+export function cloneForStep(forStep: ForStep): ForStep {
     return cloneForStepWithIdentities(forStep, {
         stepId: getNewStepId(CONSTANTS.Enums.StepKind.for),
         whatId: getNewStepId(CONSTANTS.Enums.StepKind.tool),
@@ -62,7 +62,7 @@ export function cloneForStep(forStep: ForStepJson): ForStepJson {
     });
 }
 
-export function cloneWhileStep(whileStep: WhileStepJson): WhileStepJson {
+export function cloneWhileStep(whileStep: WhileStep): WhileStep {
     return cloneWhileStepWithIdentities(whileStep, {
         stepId: getNewStepId(CONSTANTS.Enums.StepKind.while),
         whatId: getNewStepId(CONSTANTS.Enums.StepKind.tool),

package/src/integrations/firebase/firebaseAdminHelpers.ts

@@ -1,17 +1,18 @@
 import type {
-    ResourceJson,
-    ResourceTypeIdJson,
-    StepKindJson,
+    Resource,
+    ResourceTypeId,
+    StepKind,
 } from '@toolproof-core/schema';
 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;
@@ -31,7 +32,7 @@ export function getNewId<K extends IdName>(idName: K): IdStringByIdName<K> {
     return (prefix + docRef.id) as IdStringByIdName<K>;
 }
 
-export function getNewStepId<K extends StepKindJson>(stepKind: K): StepIdStringByStepKind<K> {
+export function getNewStepId<K extends StepKind>(stepKind: K): StepIdStringByStepKind<K> {
     const idName = `${capitalizeFirst(stepKind)}StepId` as IdName;
 
     if (!(idName in MAPPINGS.IdNameToIdPrefix)) {
@@ -42,13 +43,13 @@ export function getNewStepId<K extends StepKindJson>(stepKind: K): StepIdStringB
 }
 
 export async function listResources(
-    resourceTypeIds: ResourceTypeIdJson[],
+    resourceTypeIds: ResourceTypeId[],
 ): Promise<ResourcesByType> {
     const bucketResources = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_resources);
     const bucketStrategies = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_strategies);
 
     async function fetchFilesUnder(
-        resourceTypeId: ResourceTypeIdJson,
+        resourceTypeId: ResourceTypeId,
     ): Promise<Array<{ data: unknown; meta: any; name: string }>> {
         const bucket = resourceTypeId === CONSTANTS.Cosmos.TYPE_RunnableStrategy
             ? bucketStrategies
@@ -81,7 +82,7 @@ export async function listResources(
     const entries = await Promise.all(
         resourceTypeIds.map(async (resourceTypeId) => {
             const rows = await fetchFilesUnder(resourceTypeId);
-            const items: ResourceJson[] = rows.map(({ data, meta, name }) => {
+            const items: Resource[] = rows.map(({ data, meta, name }) => {
                 const flat = meta?.metadata ?? {};
                 const root: any = {};
 
@@ -184,7 +185,7 @@ export async function listResources(
                     timestamp: timestamp as string,
                     path: resourcePath as string,
                     nucleus: data as any,
-                } as unknown as ResourceJson;
+                } as unknown as Resource;
             });
 
             return [resourceTypeId, items] as const;

package/src/types/types.ts

@@ -1,7 +1,7 @@
 import type {
-    StepKindJson,
-    ResourceJson,
-    ResourceTypeIdJson,
+    StepKind,
+    Resource,
+    ResourceTypeId,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../artifacts/artifacts.js';
 import { MAPPINGS } from '../artifacts/artifacts.js';
@@ -12,13 +12,13 @@ export type Collection = keyof typeof CONSTANTS.Persistence.Collections;
 
 export type SchemaLike = Record<string, unknown>;
 
-export type ResourcesByType = Record<ResourceTypeIdJson, ResourceJson[]>;
+export type ResourcesByType = Record<ResourceTypeId, Resource[]>;
 
 export type IdName = keyof typeof MAPPINGS.IdNameToIdPrefix;
 
 export type IdStringByIdName<K extends IdName> = `${(typeof MAPPINGS.IdNameToIdPrefix)[K]}${string}`;
 
-export type StepIdStringByStepKind<K extends StepKindJson> = `${(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,53 @@
 import type {
-    CreationContextJson,
-    ExternalInputPotentialShellJson,
-    InternalInputPotentialShellJson,
-    OutputPotentialShellJson,
-    ResourceJson,
-    ResourcePotentialJson,
-    StrategyStateJson,
+    CreationContext,
+    Resource,
+    ReferenceInput,
+    ValueInput,
 } from '@toolproof-core/schema';
-import { CONSTANTS } from '../artifacts/artifacts.js';
-import { resolveResourceChain } from './resolveResourceChain.js';
+import {
+    clearStrategyStateEntry,
+    getStrategyStateEntry,
+    setStrategyStateEntry,
+    type StrategyState,
+} from './strategyState.js';
 
 
 export function bindInputResInStrategyState(
-    strategyState: StrategyStateJson,
-    target: CreationContextJson,
-    resource: ResourceJson
-): StrategyStateJson {
-    const bucket = strategyState[target.toolStepId] ?? {};
-    return {
-        ...strategyState,
-        [target.toolStepId]: {
-            ...bucket,
-            [target.resourceRoleId]: resource,
-        },
+    strategyState: StrategyState,
+    target: CreationContext,
+    resource: Resource
+): StrategyState {
+    const entry: ValueInput = {
+        strategyStateInputKind: 'valueInput',
+        resourceTypeId: resource.resourceTypeId,
+        nucleus: resource.nucleus,
     };
+
+    return setStrategyStateEntry(strategyState, target, entry);
 }
 
 export function bindInputRefInStrategyState(
-    strategyState: StrategyStateJson,
-    target: CreationContextJson,
-    source: CreationContextJson
-): StrategyStateJson {
-    const sourceEntry = strategyState?.[source.toolStepId]?.[source.resourceRoleId] as (
-        | ResourceJson
-        | ResourcePotentialJson
-        | undefined
-    );
+    strategyState: StrategyState,
+    target: CreationContext,
+    source: CreationContext
+): StrategyState {
+    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: ExternalInputPotentialShellJson = {
-            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: InternalInputPotentialShellJson = {
-            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: StrategyStateJson,
-    target: CreationContextJson
-): StrategyStateJson {
-    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,
-    };
+    strategyState: StrategyState,
+    target: CreationContext
+): StrategyState {
+    return clearStrategyStateEntry(strategyState, target);
 }

package/src/utils/creation/resourceCreation.ts

@@ -1,31 +1,47 @@
 import type {
-    CreationContextJson,
-    ExternalInputPotentialShellJson,
-    InternalInputPotentialShellJson,
-    OutputPotentialShellJson,
-    ResourceIdJson,
-    ResourceJson,
-    ResourceTypeIdJson,
+    CreationContext,
+    ExternalInput,
+    ReferenceInput,
+    ResourceId,
+    Resource,
+    ResourceTypeId,
+    StrategyRunId,
 } from '@toolproof-core/schema';
-import { CONSTANTS } from '../../artifacts/artifacts.js';
 
-export function generatePath(resourceTypeId: ResourceTypeIdJson, id: ResourceIdJson): string {
+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: OutputPotentialShellJson,
+    outputPotential: OutputPotential,
     nucleus: unknown,
     timestamp?: string,
-): ResourceJson {
+): Resource {
     const { id, resourceTypeId, creationContext } = outputPotential;
     const path = generatePath(resourceTypeId, id);
 
     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,18 +50,21 @@ export function createMaterializedFromOutputPotential(
 }
 
 export function createMaterializedFromInputPotential(
-    inputPotential: InternalInputPotentialShellJson,
+    inputPotential: InputPotential,
     nucleus: unknown,
     timestamp?: string,
-): ResourceJson {
+): Resource {
     const { id, resourceTypeId, creationContext } = inputPotential;
     const path = generatePath(resourceTypeId, id);
 
     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: InternalInputPotentialShellJson | OutputPotentialShellJson,
+    potential: InputPotential | OutputPotential,
     nucleus: unknown,
     timestamp?: string,
-): ResourceJson {
-    if (potential.resourceShellKind === CONSTANTS.Enums.ResourceShellKind.internalInputPotential) {
+): Resource {
+    if ('strategyStateInputKind' in potential && potential.strategyStateInputKind === 'referenceInput') {
         return createMaterializedFromInputPotential(potential, nucleus, timestamp);
     }
 
@@ -66,38 +85,37 @@ export function createMaterializedFromPotential(
 }
 
 export function createExternalInputPotential(
-    id: ResourceIdJson,
-    resourceTypeId: ResourceTypeIdJson,
-): ExternalInputPotentialShellJson {
+    _id: ResourceId,
+    _resourceTypeId: ResourceTypeId,
+): ExternalInput {
     return {
-        id,
-        resourceTypeId,
-        resourceShellKind: CONSTANTS.Enums.ResourceShellKind.externalInputPotential,
+        strategyStateInputKind: 'externalInput',
     };
 }
 
 export function createInputPotential(
-    id: ResourceIdJson,
-    resourceTypeId: ResourceTypeIdJson,
-    creationContext: CreationContextJson,
-): InternalInputPotentialShellJson {
+    id: ResourceId,
+    resourceTypeId: ResourceTypeId,
+    creationContext: CreationContext,
+): InputPotential {
     return {
         id,
         resourceTypeId,
+        strategyStateInputKind: 'referenceInput',
+        toolStepPath: creationContext.toolStepPath,
+        roleName: creationContext.roleName,
         creationContext,
-        resourceShellKind: CONSTANTS.Enums.ResourceShellKind.internalInputPotential,
     };
 }
 
 export function createOutputPotential(
-    id: ResourceIdJson,
-    resourceTypeId: ResourceTypeIdJson,
-    creationContext: CreationContextJson,
-): OutputPotentialShellJson {
+    id: ResourceId,
+    resourceTypeId: ResourceTypeId,
+    creationContext: CreationContext,
+): OutputPotential {
     return {
         id,
         resourceTypeId,
         creationContext,
-        resourceShellKind: CONSTANTS.Enums.ResourceShellKind.outputPotential,
     };
 }

package/src/utils/creation/runnableStrategyCreation.ts

@@ -1,42 +1,28 @@
 import type {
-    RawStrategyJson,
-    RunnableStrategyIdJson,
-    RunnableStrategyJson,
-    StepJson,
-    StepArrayByStrategyThreadJson,
-    StrategyThreadIdJson,
+    Step,
+    Strategy,
+    StrategyId,
 } from '@toolproof-core/schema';
 import { getIndependentThreads } from '../parallelizeSteps.js';
+import { CONSTANTS } from '../../artifacts/artifacts.js';
 
-export function getRunnableStrategyThreadGroups(rawStrategy: RawStrategyJson): StepJson[][] {
-    return getIndependentThreads(rawStrategy.steps, rawStrategy.strategyState);
-}
-
-export function buildRunnableStrategy(
-    rawStrategy: RawStrategyJson,
-    runnableStrategyId: RunnableStrategyIdJson,
-    threadStepGroups: StepJson[][],
-    threadIdentities: StrategyThreadIdJson[],
-): RunnableStrategyJson {
-    if (threadStepGroups.length !== threadIdentities.length) {
-        throw new Error('buildRunnableStrategy requires one thread id per thread group');
+export function getRunnableStrategyThreadGroups(rawStrategy: Strategy): Step[][] {
+    if ('steps' in rawStrategy) {
+        return getIndependentThreads(rawStrategy.steps, rawStrategy.strategyState as any);
     }
 
-    const stepsByStrategyThread: StepArrayByStrategyThreadJson = {};
-
-    for (const [index, group] of threadStepGroups.entries()) {
-        const threadId = threadIdentities[index];
-
-        if (!threadId) {
-            throw new Error(`Missing thread id for thread group index ${index}`);
-        }
-
-        stepsByStrategyThread[threadId] = group;
-    }
+    return rawStrategy.stepsByThreadIndex;
+}
 
+export function buildRunnableStrategy(
+    threadStepGroups: Step[][],
+    runnableStrategyId: StrategyId,
+    rawStrategy: Strategy,
+): Strategy {
     return {
         id: runnableStrategyId,
-        stepsByStrategyThread,
+        strategyKind: CONSTANTS.Enums.StrategyKind.threaded,
+        stepsByThreadIndex: threadStepGroups,
         strategyState: rawStrategy.strategyState,
     };
 }