@toolproof-core/lib 1.0.34 → 1.0.37

package/src/utils/mutableStrategyOverlay.ts

@@ -0,0 +1,286 @@
+import type {
+    BranchStep,
+    Case,
+    ExternalInputPotential,
+    ForStep,
+    InputResource,
+    InternalInputPotential,
+    Resource,
+    RoleName,
+    Strategy,
+    Tool,
+    ToolHandle,
+    ToolStep,
+    ToolStepRoleAddress,
+    WhileStep,
+} from '@toolproof-core/genesis';
+import { extractResourceTypeHandleFromRoleValue } from './strategyExtraction.js';
+
+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 function getAuthoringSteps<
+    TKey extends string = MutableToolStepKey,
+    TStep extends MutableStep<TKey> = MutableStep<TKey>,
+    TState extends MutableStrategyState<TKey> = MutableStrategyState<TKey>,
+>(
+    strategy: MutableStrategy<TKey, TStep, TState>,
+): TStep[] {
+    return strategy.stepsByThreadIndex[0] ?? [];
+}
+
+export 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> {
+    const nextStepsByThreadIndex = [...strategy.stepsByThreadIndex];
+    nextStepsByThreadIndex[0] = steps;
+
+    return {
+        ...strategy,
+        stepsByThreadIndex: nextStepsByThreadIndex,
+    };
+}
+
+export function getStrategyStateInputEntryByRoleName<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
+    strategyState: TStrategyState,
+    toolStepKey: TKey,
+): MutableStrategyStateInputEntryByRoleName<TKey> | undefined {
+    return strategyState[toolStepKey];
+}
+
+export function getStrategyStateInputEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
+    strategyState: TStrategyState,
+    toolStepRoleAddress: MutableToolStepRoleAddress<TKey>,
+): MutableStrategyStateInputEntry<TKey> | undefined {
+    const inputEntryByRoleName = getStrategyStateInputEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey);
+    return inputEntryByRoleName?.[toolStepRoleAddress.roleName];
+}
+
+export function setStrategyStateInputEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
+    strategyState: TStrategyState,
+    toolStepRoleAddress: MutableToolStepRoleAddress<TKey>,
+    entry: MutableStrategyStateInputEntry<TKey>,
+): TStrategyState {
+    const inputEntryByRoleName = getStrategyStateInputEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey) ?? {};
+
+    return {
+        ...strategyState,
+        [toolStepRoleAddress.toolStepKey]: {
+            ...inputEntryByRoleName,
+            [toolStepRoleAddress.roleName]: entry,
+        },
+    };
+}
+
+export function clearInputBinding<
+    TKey extends string,
+    TStrategyState extends MutableStrategyState<TKey>
+>(
+    strategyState: TStrategyState,
+    toolStepRoleAddress: MutableToolStepRoleAddress<TKey>,
+): TStrategyState {
+    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 as TStrategyState;
+    }
+
+    return {
+        ...strategyState,
+        [toolStepRoleAddress.toolStepKey]: nextInputEntryByRoleName,
+    };
+}
+
+export function bindInputResource<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
+    strategyState: TStrategyState,
+    target: MutableToolStepRoleAddress<TKey>,
+    resource: Resource,
+): TStrategyState {
+    const mutableInputResource: MutableInputResource = {
+        ...resource,
+        strategyStateInputKind: 'inputResource',
+    };
+
+    return setStrategyStateInputEntry(strategyState, target, mutableInputResource);
+}
+
+function getInputRoleValue(tool: Tool, roleName: RoleName) {
+    return tool.roleSpec.inputRoleValueByName[roleName];
+}
+
+function getOutputRoleValue(tool: Tool, roleName: RoleName) {
+    return tool.roleSpec.outputRoleValueByName[roleName];
+}
+
+export 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 {
+
+    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<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(
+    strategyState: TStrategyState,
+    target: MutableToolStepRoleAddress<TKey>,
+): TStrategyState {
+    const mutableExternalInputPotential: MutableExternalInputPotential = {
+        strategyStateInputKind: 'externalInputPotential',
+    };
+
+    return setStrategyStateInputEntry(strategyState, target, mutableExternalInputPotential);
+}

package/src/utils/resourceCreation.ts

@@ -0,0 +1,87 @@
+import type {
+    ToolStepRoleAddress,
+    ResourceId,
+    Resource,
+    ResourcePointer,
+    ResourceTypeHandle,
+    RuntimeProvenance,
+    StrategyProvenance,
+    Provenance,
+    StrategyTraceHandle,
+} from '@toolproof-core/genesis';
+import { CONSTANTS } from '../lookups/lookups.js';
+
+
+export type ResourceCreationDescriptor =
+    | {
+        id: ResourceId;
+        resourceTypeHandle: ResourceTypeHandle;
+    }
+    | {
+        id: ResourceId;
+        resourceTypeHandle: ResourceTypeHandle;
+        toolStepRoleAddress: ToolStepRoleAddress;
+        strategyTraceHandle: StrategyTraceHandle;
+    };
+
+function createStrategyProvenance(
+    strategyTraceHandle: StrategyTraceHandle,
+    toolStepRoleAddress: ToolStepRoleAddress,
+): StrategyProvenance {
+    return {
+        provenanceKind: CONSTANTS.Enums.ProvenanceKind.strategy,
+        strategyTraceHandle,
+        toolStepRoleAddress,
+    };
+}
+
+function createRuntimeProvenance(): RuntimeProvenance {
+    return {
+        provenanceKind: CONSTANTS.Enums.ProvenanceKind.runtime,
+    };
+}
+
+function createResourcePointer(
+    id: ResourceId,
+    resourceTypeHandle: ResourceTypeHandle,
+    provenance: Provenance,
+): ResourcePointer {
+    return {
+        id,
+        resourceTypeHandle,
+        provenance,
+    };
+}
+
+function createResource(
+    resourcePointer: ResourcePointer,
+    projection: unknown,
+): Resource {
+    return {
+        ...resourcePointer,
+        projection,
+    };
+}
+
+export function createResourceFromDescriptor(
+    descriptor: ResourceCreationDescriptor,
+    projection: unknown,
+): Resource {
+    const provenance =
+        'toolStepRoleAddress' in descriptor
+            ? createStrategyProvenance(
+                descriptor.strategyTraceHandle,
+                descriptor.toolStepRoleAddress,
+            )
+            : createRuntimeProvenance();
+
+    return createResource(
+        createResourcePointer(
+            descriptor.id,
+            descriptor.resourceTypeHandle,
+            provenance,
+        ),
+        projection,
+    );
+}
+

package/src/utils/stepCreation.ts

@@ -0,0 +1,114 @@
+import type {
+    Tool,
+} from '@toolproof-core/genesis';
+import type {
+    MutableToolStep,
+    MutableCase,
+    MutableWhileStep,
+    MutableForStep,
+    MutableBranchStep,
+} from './mutableStrategyOverlay.js';
+import { CONSTANTS } from '../lookups/lookups.js';
+import { getInputRoleNamesFromTool, getOutputRoleNamesFromTool } from './strategyExtraction.js';
+import { generateIdentifier } from './identifierGeneration.js';
+
+
+function assertNonEmpty<T>(arr: T[], msg: string): asserts arr is [T, ...T[]] {
+    if (arr.length === 0) {
+        throw new Error(msg);
+    }
+}
+
+function getRoleBindingSpec(tool: Tool): MutableToolStep['roleBindingSpec'] {
+    return {
+        inputBindings: getInputRoleNamesFromTool(tool),
+        outputBindings: getOutputRoleNamesFromTool(tool),
+    };
+}
+
+export function createToolStepFromTool(
+    tool: Tool,
+): MutableToolStep {
+    return {
+        toolStepKey: generateIdentifier('ToolStepKey'),
+        stepKind: CONSTANTS.Enums.StepKind.tool,
+        toolHandle: tool.handle,
+        roleBindingSpec: getRoleBindingSpec(tool),
+    };
+}
+
+export function createCaseFromToolStepPair(
+    what: MutableToolStep,
+    when: MutableToolStep,
+): MutableCase {
+    return { what, when };
+}
+
+export function createLoopStepFromCase(
+    stepCase: MutableCase,
+    stepKind: typeof CONSTANTS.Enums.StepKind.for | typeof CONSTANTS.Enums.StepKind.while,
+): MutableForStep | MutableWhileStep {
+    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: MutableCase[],
+): MutableBranchStep {
+    assertNonEmpty(cases, 'createBranchStepFromCases requires at least one case');
+
+    return {
+        macroStepKey: generateIdentifier('BranchStepKey'),
+        stepKind: CONSTANTS.Enums.StepKind.branch,
+        cases,
+    };
+}
+
+export function cloneForStep(
+    forStep: MutableForStep,
+): MutableForStep {
+    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: MutableWhileStep,
+): MutableWhileStep {
+    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/src/utils/stepParallelization.ts

@@ -0,0 +1,181 @@
+import type {
+	MutableBranchStep,
+	MutableForStep,
+	MutableStep,
+	MutableStrategyState,
+	MutableToolStep,
+	MutableToolStepKey,
+	MutableWhileStep,
+} from './mutableStrategyOverlay.js';
+import { CONSTANTS } from '../lookups/lookups.js';
+
+export function getIndependentThreads<
+	TKey extends string = MutableToolStepKey,
+	TStep extends MutableStep<TKey> = MutableStep<TKey>,
+>(
+	steps: TStep[],
+	strategyState: MutableStrategyState<TKey>,
+): TStep[][] {
+	type OwnerIndex = number;
+
+	const getOwnerLabel = (ownerIndex: OwnerIndex) => {
+		const step = steps[ownerIndex];
+		return `steps[${ownerIndex}] stepKind=${step?.stepKind ?? 'unknown'}`;
+	};
+
+	const toolStepKeyToOwner = new Map<TKey, OwnerIndex>();
+	const toolStepByKey = new Map<TKey, MutableToolStep<TKey>>();
+
+	const addToolStep = (
+		toolStep: MutableToolStep<TKey> | undefined,
+		ownerIndex: OwnerIndex,
+	) => {
+		if (!toolStep) return;
+
+		const existingOwner = toolStepKeyToOwner.get(toolStep.toolStepKey);
+		if (existingOwner !== undefined) {
+			throw new Error(
+				`Duplicate toolStepKey '${toolStep.toolStepKey}' found in ${getOwnerLabel(ownerIndex)} and ${getOwnerLabel(existingOwner)}`
+			);
+		}
+
+		toolStepKeyToOwner.set(toolStep.toolStepKey, ownerIndex);
+		toolStepByKey.set(toolStep.toolStepKey, toolStep);
+	};
+
+	steps.forEach((step, ownerIndex) => {
+		if (step.stepKind === CONSTANTS.Enums.StepKind.tool) {
+			addToolStep(step as MutableToolStep<TKey>, ownerIndex);
+			return;
+		}
+
+		if (step.stepKind === CONSTANTS.Enums.StepKind.for) {
+			const loop = step as MutableForStep<TKey>;
+			addToolStep(loop.case?.what, ownerIndex);
+			addToolStep(loop.case?.when, ownerIndex);
+			return;
+		}
+
+		if (step.stepKind === CONSTANTS.Enums.StepKind.while) {
+			const loop = step as MutableWhileStep<TKey>;
+			addToolStep(loop.case?.what, ownerIndex);
+			addToolStep(loop.case?.when, ownerIndex);
+			return;
+		}
+
+		if (step.stepKind === CONSTANTS.Enums.StepKind.branch) {
+			const branch = step as MutableBranchStep<TKey>;
+			for (const stepCase of branch.cases) {
+				addToolStep(stepCase?.what, ownerIndex);
+				addToolStep(stepCase?.when, ownerIndex);
+			}
+		}
+	});
+
+	const ownerAdj = new Map<OwnerIndex, Set<OwnerIndex>>();
+	const ownerDeps = new Map<OwnerIndex, Set<OwnerIndex>>();
+
+	const ensureOwner = (ownerIndex: OwnerIndex) => {
+		if (!ownerAdj.has(ownerIndex)) ownerAdj.set(ownerIndex, new Set());
+		if (!ownerDeps.has(ownerIndex)) ownerDeps.set(ownerIndex, new Set());
+	};
+
+	for (let index = 0; index < steps.length; index++) {
+		ensureOwner(index);
+	}
+
+	for (const [toolStepKey, ownerIndex] of toolStepKeyToOwner) {
+		ensureOwner(ownerIndex);
+
+		const toolStep = toolStepByKey.get(toolStepKey);
+		const inputBindings = toolStep?.roleBindingSpec?.inputBindings ?? [];
+		const bucket = strategyState[toolStepKey];
+
+		for (const inputRoleId of inputBindings) {
+			const entry = bucket?.[inputRoleId];
+			if (!entry || entry.strategyStateInputKind !== 'internalInputPotential') continue;
+
+			const producerToolStepKey = entry.toolStepRoleAddress?.toolStepKey;
+			if (typeof producerToolStepKey !== 'string') {
+				throw new Error(
+					`Unresolvable internalInputPotential in toolStep '${toolStepKey}' (${getOwnerLabel(ownerIndex)}): missing toolStepRoleAddress.toolStepKey for role '${inputRoleId}'`
+				);
+			}
+
+			const producerOwner = toolStepKeyToOwner.get(producerToolStepKey as TKey);
+			if (producerOwner === undefined) {
+				throw new Error(
+					`Unresolvable internalInputPotential in toolStep '${toolStepKey}' (${getOwnerLabel(ownerIndex)}): source toolStepKey '${producerToolStepKey}' not found in strategy steps`
+				);
+			}
+
+			ensureOwner(producerOwner);
+			ownerAdj.get(ownerIndex)?.add(producerOwner);
+			ownerAdj.get(producerOwner)?.add(ownerIndex);
+			ownerDeps.get(ownerIndex)?.add(producerOwner);
+		}
+	}
+
+	const visited = new Set<OwnerIndex>();
+	const components: OwnerIndex[][] = [];
+
+	for (let ownerIndex = 0; ownerIndex < steps.length; ownerIndex++) {
+		if (visited.has(ownerIndex)) continue;
+
+		const component: OwnerIndex[] = [];
+		const queue: OwnerIndex[] = [ownerIndex];
+		visited.add(ownerIndex);
+
+		while (queue.length > 0) {
+			const node = queue.shift();
+			if (node === undefined) break;
+			component.push(node);
+
+			for (const neighbor of ownerAdj.get(node) ?? []) {
+				if (visited.has(neighbor)) continue;
+				visited.add(neighbor);
+				queue.push(neighbor);
+			}
+		}
+
+		components.push(component);
+	}
+
+	for (const component of components) {
+		const componentOwners = new Set(component);
+		const ownersInOrder = steps.map((_, index) => index).filter((index) => componentOwners.has(index));
+		const position = new Map<OwnerIndex, number>();
+
+		ownersInOrder.forEach((owner, index) => position.set(owner, index));
+
+		for (const consumerOwner of ownersInOrder) {
+			const deps = ownerDeps.get(consumerOwner);
+			if (!deps || deps.size === 0) continue;
+
+			const consumerPos = position.get(consumerOwner);
+			if (consumerPos === undefined) continue;
+
+			for (const producerOwner of deps) {
+				const producerPos = position.get(producerOwner);
+				if (producerPos === undefined) {
+					throw new Error(
+						`Internal error: dependency producer ${getOwnerLabel(producerOwner)} missing from computed thread for ${getOwnerLabel(consumerOwner)}`
+					);
+				}
+
+				if (producerPos >= consumerPos) {
+					throw new Error(
+						`Invalid step order in thread: ${getOwnerLabel(consumerOwner)} depends on ${getOwnerLabel(producerOwner)}, but producer is not scheduled before consumer`
+					);
+				}
+			}
+		}
+	}
+
+	return components
+		.map((component) => {
+			const ownerSet = new Set(component);
+			return steps.filter((_step, index) => ownerSet.has(index));
+		})
+		.filter((group) => group.length > 0);
+}

package/src/utils/strategyAssembly.ts

@@ -0,0 +1,14 @@
+import type { Strategy } from '@toolproof-core/genesis';
+import type { MutableStrategy } from './mutableStrategyOverlay.js';
+import { toExecutionMutableStrategy } from './strategyThreading.js';
+import { mutableStrategyToStrategy } from './strategyCanonicalization.js';
+
+
+export function composeStrategyForExecution<TKey extends string>(
+    mutableStrategy: MutableStrategy<TKey>,
+): Strategy {
+    const executionStrategy =
+        toExecutionMutableStrategy(mutableStrategy);
+
+    return mutableStrategyToStrategy(executionStrategy);
+}