@toolproof-core/lib 1.0.36 → 1.0.37

package/dist/utils/strategyState.js

@@ -1,58 +0,0 @@
-export function getStrategyStateBucket(strategyState, toolStepPath) {
-    return strategyState[toolStepPath];
-}
-export function getStrategyStateEntry(strategyState, toolStepRoleAddress) {
-    const toolStepPath = toolStepRoleAddress.toolStepPath;
-    return getStrategyStateBucket(strategyState, toolStepPath)?.[toolStepRoleAddress.roleName];
-}
-export function setStrategyStateEntry(strategyState, toolStepRoleAddress, entry) {
-    const toolStepPath = toolStepRoleAddress.toolStepPath;
-    const bucket = getStrategyStateBucket(strategyState, toolStepPath) ?? {};
-    return {
-        ...strategyState,
-        [toolStepPath]: {
-            ...bucket,
-            [toolStepRoleAddress.roleName]: entry,
-        },
-    };
-}
-export function clearStrategyStateEntry(strategyState, toolStepRoleAddress) {
-    const toolStepPath = toolStepRoleAddress.toolStepPath;
-    const bucket = getStrategyStateBucket(strategyState, toolStepPath);
-    if (!bucket || !(toolStepRoleAddress.roleName in bucket)) {
-        return strategyState;
-    }
-    const nextBucket = { ...bucket };
-    delete nextBucket[toolStepRoleAddress.roleName];
-    return {
-        ...strategyState,
-        [toolStepPath]: nextBucket,
-    };
-}
-export function bindInputResource(strategyState, target, resource) {
-    const inputResource = {
-        ...resource,
-        strategyStateInputKind: 'inputResource',
-    };
-    return setStrategyStateEntry(strategyState, target, inputResource);
-}
-export function bindInternalInputPotential(strategyState, target, source) {
-    const sourceEntry = getStrategyStateEntry(strategyState, source);
-    if (!sourceEntry) {
-        throw new Error(`resourceEntry not found for source (${source.toolStepPath}, ${source.roleName})`);
-    }
-    const internalInputPotential = {
-        strategyStateInputKind: 'internalInputPotential',
-        toolStepRoleAddress: {
-            toolStepPath: source.toolStepPath,
-            roleName: source.roleName,
-        },
-    };
-    return setStrategyStateEntry(strategyState, target, internalInputPotential);
-}
-export function bindExternalInputPotential(strategyState, target) {
-    const externalInputPotential = {
-        strategyStateInputKind: 'externalInputPotential',
-    };
-    return setStrategyStateEntry(strategyState, target, externalInputPotential);
-}

package/dist/utils_2/threadedStrategyCreation.d.ts

@@ -1,5 +0,0 @@
-import type { UnthreadedStrategy, ThreadedStrategy, StepArray, StepArrayArray, UnthreadedStrategyState, ThreadedStrategyState } from "@toolproof-core/genesis/types";
-export declare const __UnthreadedStrategyToThreadedStrategy: (unthreadedStrategy: UnthreadedStrategy) => ThreadedStrategy;
-export declare const __UnthreadedStrategyStateToThreadedStrategyState: (unthreadedStrategyState: UnthreadedStrategyState) => ThreadedStrategyState;
-export declare const __StepArrayToStepArrayArray: (stepArray: StepArray) => StepArrayArray;
-export declare const __Foo: (unthreadedStrategy: UnthreadedStrategy, draft: any) => UnthreadedStrategy;

package/dist/utils_2/threadedStrategyCreation.js

@@ -1,12 +0,0 @@
-export const __UnthreadedStrategyToThreadedStrategy = (unthreadedStrategy) => {
-    throw new Error('Not implemented yet');
-};
-export const __UnthreadedStrategyStateToThreadedStrategyState = (unthreadedStrategyState) => {
-    throw new Error('Not implemented yet');
-};
-export const __StepArrayToStepArrayArray = (stepArray) => {
-    throw new Error('Not implemented yet');
-};
-export const __Foo = (unthreadedStrategy, draft) => {
-    throw new Error('Not implemented yet');
-};

package/src/integrations/firebase/createStep.ts

@@ -1,41 +0,0 @@
-import type {
-    BranchStep,
-    ForStep,
-    Tool,
-    ToolStep,
-    WhileStep,
-} from '@toolproof-core/genesis';
-import { CONSTANTS } from '../../lookups/lookups.js';
-import {
-    buildBranchStepFromToolPairs,
-    buildToolStepFromTool,
-    buildLoopStepFromToolPair,
-    cloneForStep as cloneForStepPure,
-    cloneWhileStep as cloneWhileStepPure,
-} from '../../utils/creation/stepCreation.js';
-
-export function createToolStepFromTool(tool: Tool): ToolStep {
-    return buildToolStepFromTool(tool);
-}
-
-export function createLoopStepFromToolPair(
-    whatTool: Tool,
-    whenTool: Tool,
-    stepKind: typeof CONSTANTS.Enums.StepKind.for | typeof CONSTANTS.Enums.StepKind.while,
-): ForStep | WhileStep {
-    return buildLoopStepFromToolPair(whatTool, whenTool, stepKind);
-}
-
-export function createBranchStepFromToolPairs(
-    cases: Array<{ whatTool: Tool; whenTool: Tool }>,
-): BranchStep {
-    return buildBranchStepFromToolPairs(cases);
-}
-
-export function cloneForStep(forStep: ForStep): ForStep {
-    return cloneForStepPure(forStep);
-}
-
-export function cloneWhileStep(whileStep: WhileStep): WhileStep {
-    return cloneWhileStepPure(whileStep);
-}

package/src/integrations/firebase/createThreadedStrategy.ts

@@ -1,19 +0,0 @@
-import { CONSTANTS } from '../../lookups/lookups.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 strategyHandle = getNewId(CONSTANTS.Names.StrategyHandle);
-
-    return buildThreadedStrategy(
-        threadStepGroups,
-        strategyHandle,
-        strategy,
-    );
-}

package/src/utils/creation/resourceCreation.ts

@@ -1,140 +0,0 @@
-import type {
-    ToolStepRoleAddress,
-    ExternalInputPotential,
-    InternalInputPotential,
-    ResourceId,
-    Resource,
-    ResourcePointer,
-    ResourceTypeHandle,
-    StrategyProvenance,
-    Provenance,
-    StrategyTraceHandle,
-} from '@toolproof-core/genesis';
-
-type RuntimeProvenance = Extract<Provenance, { provenanceKind: 'runtime' }>;
-
-export interface OutputPotential {
-    id: ResourceId;
-    resourceTypeHandle: ResourceTypeHandle;
-    toolStepRoleAddress?: ToolStepRoleAddress;
-    strategyTraceHandle?: StrategyTraceHandle;
-    provenanceKind?: Provenance['provenanceKind'];
-}
-
-export function createExternalInputPotential(): ExternalInputPotential {
-    return {
-        strategyStateInputKind: 'externalInputPotential',
-    };
-}
-
-export function createInternalInputPotential(
-    toolStepRoleAddress: ToolStepRoleAddress,
-): InternalInputPotential {
-    return {
-        strategyStateInputKind: 'internalInputPotential',
-        toolStepRoleAddress,
-    };
-}
-
-export function createStrategyProvenance(
-    strategyTraceHandle: StrategyTraceHandle,
-    toolStepRoleAddress: ToolStepRoleAddress,
-): StrategyProvenance {
-    return {
-        provenanceKind: 'strategy',
-        strategyTraceHandle,
-        toolStepRoleAddress,
-    };
-}
-
-export function createRuntimeProvenance(): RuntimeProvenance {
-    return {
-        provenanceKind: 'runtime',
-    };
-}
-
-export function createResourcePointer(
-    id: ResourceId,
-    resourceTypeHandle: ResourceTypeHandle,
-    provenance: Provenance,
-): ResourcePointer {
-    return {
-        id,
-        resourceTypeHandle,
-        provenance,
-    };
-}
-
-export function createResource(
-    resourcePointer: ResourcePointer,
-    projection: unknown,
-): Resource {
-    return {
-        ...resourcePointer,
-        projection,
-    };
-}
-
-export function createMaterializedFromOutputPotential(
-    outputPotential: OutputPotential,
-    projection: unknown,
-): Resource {
-    const provenance = outputPotential.provenanceKind === 'runtime'
-        ? createRuntimeProvenance()
-        : createStrategyProvenance(
-            requireStrategyTraceHandle(outputPotential.strategyTraceHandle),
-            requireToolStepRoleAddress(outputPotential.toolStepRoleAddress),
-        );
-
-    const resourcePointer = createResourcePointer(
-        outputPotential.id,
-        outputPotential.resourceTypeHandle,
-        provenance,
-    );
-
-    return createResource(resourcePointer, projection);
-}
-
-export function createMaterializedFromPotential(
-    outputPotential: OutputPotential,
-    projection: unknown,
-): Resource {
-    return createMaterializedFromOutputPotential(outputPotential, projection);
-}
-
-export function createOutputPotential(
-    id: ResourceId,
-    resourceTypeHandle: ResourceTypeHandle,
-    toolStepRoleAddress?: ToolStepRoleAddress,
-    strategyTraceHandle?: StrategyTraceHandle,
-    provenanceKind?: Provenance['provenanceKind'],
-): OutputPotential {
-    return {
-        id,
-        resourceTypeHandle,
-        ...(toolStepRoleAddress ? { toolStepRoleAddress } : {}),
-        ...(strategyTraceHandle ? { strategyTraceHandle } : {}),
-        ...(provenanceKind ? { provenanceKind } : {}),
-    };
-}
-
-function requireStrategyTraceHandle(
-    strategyTraceHandle: StrategyTraceHandle | undefined,
-): StrategyTraceHandle {
-    if (!strategyTraceHandle) {
-        throw new Error('strategyTraceHandle is required to materialize a strategy output potential');
-    }
-
-    return strategyTraceHandle;
-}
-
-function requireToolStepRoleAddress(
-    toolStepRoleAddress: ToolStepRoleAddress | undefined,
-): ToolStepRoleAddress {
-    if (!toolStepRoleAddress) {
-        throw new Error('toolStepRoleAddress is required to materialize a strategy output potential');
-    }
-
-    return toolStepRoleAddress;
-}
-

package/src/utils/creation/stepCreation.ts

@@ -1,95 +0,0 @@
-import type {
-    BranchStep,
-    Case,
-    ForStep,
-    Tool,
-    ToolStep,
-    WhileStep,
-} from '@toolproof-core/genesis';
-import { CONSTANTS } from '../../lookups/lookups.js';
-import { getInputRoleNames, getOutputRoleNames } from '../roleSpec.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): ToolStep['roleBindingSpec'] {
-    return {
-        inputBindings: getInputRoleNames(tool),
-        outputBindings: getOutputRoleNames(tool),
-    };
-}
-
-export function buildToolStepFromTool(
-    tool: Tool,
-): ToolStep {
-    return {
-        stepKind: CONSTANTS.Enums.StepKind.tool,
-        toolHandle: tool.handle,
-        roleBindingSpec: getRoleBindingSpec(tool),
-    };
-}
-
-export function buildLoopStepFromToolPair(
-    whatTool: Tool,
-    whenTool: Tool,
-    stepKind: typeof CONSTANTS.Enums.StepKind.for | typeof CONSTANTS.Enums.StepKind.while,
-): ForStep | WhileStep {
-    const what = buildToolStepFromTool(whatTool);
-    const when = buildToolStepFromTool(whenTool);
-
-    if (stepKind === CONSTANTS.Enums.StepKind.for) {
-        return {
-            stepKind: CONSTANTS.Enums.StepKind.for,
-            case: { what, when },
-        };
-    }
-
-    return {
-        stepKind: CONSTANTS.Enums.StepKind.while,
-        case: { what, when },
-    };
-}
-
-export function buildBranchStepFromToolPairs(
-    cases: Array<{ whatTool: Tool; whenTool: Tool }>,
-): BranchStep {
-    const resolved = cases.map(({ whatTool, whenTool }, index) => {
-        const what = buildToolStepFromTool(whatTool);
-        const when = buildToolStepFromTool(whenTool);
-        return { what, when } satisfies Case;
-    });
-
-    assertNonEmpty(resolved, 'buildBranchStepFromToolPairs requires at least one case');
-
-    return {
-        stepKind: CONSTANTS.Enums.StepKind.branch,
-        cases: resolved,
-    };
-}
-
-export function cloneForStep(
-    forStep: ForStep,
-): ForStep {
-    return {
-        stepKind: CONSTANTS.Enums.StepKind.for,
-        case: {
-            what: { ...forStep.case.what },
-            when: { ...forStep.case.when },
-        },
-    };
-}
-
-export function cloneWhileStep(
-    whileStep: WhileStep,
-): WhileStep {
-    return {
-        stepKind: CONSTANTS.Enums.StepKind.while,
-        case: {
-            what: { ...whileStep.case.what },
-            when: { ...whileStep.case.when },
-        },
-    };
-}

package/src/utils/creation/threadedStrategyCreation.ts

@@ -1,42 +0,0 @@
-import type {
-    Step,
-    StrategyHandle,
-} from '@toolproof-core/genesis';
-import { getIndependentThreads } from '../parallelizeSteps.js';
-import { CONSTANTS } from '../../lookups/lookups.js';
-
-export type ThreadableStrategy<TStrategyState = unknown> = {
-    handle: StrategyHandle;
-    strategyState: TStrategyState;
-} & (
-    | { steps: Step[] }
-    | { stepsByThreadIndex: Step[][] }
-);
-
-export type ThreadedStrategyLike<TStrategyState = unknown> = {
-    handle: StrategyHandle;
-    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[][],
-    threadedStrategyHandle: StrategyHandle,
-    strategy: ThreadableStrategy<TStrategyState>,
-): ThreadedStrategyLike<TStrategyState> {
-    return {
-        handle: threadedStrategyHandle,
-        strategyKind: CONSTANTS.Enums.StrategyKind.threaded,
-        stepsByThreadIndex: threadStepGroups,
-        strategyState: strategy.strategyState,
-    };
-}

package/src/utils/extractData.ts

@@ -1,137 +0,0 @@
-import type {
-    RoleName,
-    ToolHandle,
-    Tool,
-    ToolStep,
-    ResourceId,
-    ResourceTypeHandle,
-    Resource,
-} from '@toolproof-core/genesis';
-import {
-    extractToolStepsFromStrategy,
-    getInputRoleEntries,
-    getOutputRoleEntries,
-    toToolRoleDescriptor,
-    type StrategyStepGraph,
-    type ToolRoleDescriptor,
-} from './roleSpec.js';
-
-const ERROR_OUTPUT_ROLE_NAME = 'ErrorOutput' as RoleName;
-
-function extractResourceTypeHandleFromRoleValue(toolRoleValue: ToolRoleDescriptor): ResourceTypeHandle | null {
-    const typeRef = toolRoleValue.typeRef;
-
-    if ('resourceTypeHandle' in typeRef) {
-        return typeRef.resourceTypeHandle;
-    }
-
-    return null;
-}
-
-
-export function extractToolHandlesFromUnthreadedStrategy(unthreadedStrategy: StrategyStepGraph): ToolHandle[] {
-    const toolSteps = extractToolStepsFromUnthreadedStrategy(unthreadedStrategy);
-    const ids = new Set<ToolHandle>();
-    for (const jStep of toolSteps) {
-        ids.add(jStep.toolHandle);
-    }
-    return Array.from(ids);
-}
-
-export function extractToolStepsFromUnthreadedStrategy(unthreadedStrategy: StrategyStepGraph): ToolStep[] {
-    return extractToolStepsFromStrategy(unthreadedStrategy);
-}
-
-
-export function extractRoleMapFromUnthreadedStrategy(unthreadedStrategy: StrategyStepGraph, toolMap: Map<ToolHandle, Tool>): Map<RoleName, ToolRoleDescriptor> {
-    const roleMap = new Map<RoleName, ToolRoleDescriptor>();
-    const toolHandles = extractToolHandlesFromUnthreadedStrategy(unthreadedStrategy);
-
-    for (const toolHandle of toolHandles) {
-        const tool = toolMap.get(toolHandle);
-        if (!tool) continue;
-
-        for (const entry of getInputRoleEntries(tool)) {
-            roleMap.set(entry[0], toToolRoleDescriptor(entry));
-        }
-        for (const entry of getOutputRoleEntries(tool)) {
-            roleMap.set(entry[0], toToolRoleDescriptor(entry));
-        }
-    }
-
-    return roleMap;
-}
-
-export function extractSingleNonErrorOutputTypeId(tool: Tool): ResourceTypeHandle | null {
-    const outputEntries = getOutputRoleEntries(tool).filter(([roleName]) => roleName !== ERROR_OUTPUT_ROLE_NAME);
-    if (!outputEntries || !outputEntries[0] || outputEntries.length !== 1) {
-        throw new Error(`Tool ${tool.handle} must have exactly one non-error output role to be branchable/loopable`);
-    } // ATTENTION_PUREIFY
-    return extractResourceTypeHandleFromRoleValue(toToolRoleDescriptor(outputEntries[0]));
-}
-
-
-
-export function extractResourceMapForType<TResource extends Resource = Resource>(
-    resourcesByType: Partial<Record<ResourceTypeHandle, TResource[]>>,
-    resourceTypeHandle: ResourceTypeHandle
-): Map<ResourceId, TResource> {
-    const resources = resourcesByType[resourceTypeHandle] ?? [];
-    const map = new Map<ResourceId, TResource>();
-
-    for (const resource of resources) {
-        map.set(resource.id, resource);
-    }
-
-    return map;
-}
-
-// Only use this for resource types whose nuclei are entity-like objects with their own intrinsic id.
-export function extractIdKeyedValueMapForType<
-    TKey extends string = string,
-    TValue extends { id: string | number | boolean } = { id: string | number | boolean },
-    TResource extends Resource = Resource
->(
-    resourcesByType: Partial<Record<ResourceTypeHandle, TResource[]>>,
-    resourceTypeHandle: ResourceTypeHandle,
-): Map<TKey, TValue> {
-    const resourceMap = extractResourceMapForType<TResource>(resourcesByType, resourceTypeHandle);
-    const out = new Map<TKey, TValue>();
-
-    for (const resource of resourceMap.values()) {
-        const data = resource.projection as unknown;
-        if (data === null || data === undefined) {
-            throw new Error(
-                `Expected resource '${resource.id}' of type '${resourceTypeHandle}' to have a projection`
-            );
-        }
-        if (typeof data !== 'object') {
-            throw new Error(
-                `Expected resource '${resource.id}' of type '${resourceTypeHandle}' to have an object projection with id`
-            );
-        }
-
-        const maybeId = (data as any).id as unknown;
-        if (maybeId === null || maybeId === undefined) {
-            throw new Error(
-                `Expected resource '${resource.id}' of type '${resourceTypeHandle}' to have projection.id`
-            );
-        }
-        if (
-            typeof maybeId !== 'string' &&
-            typeof maybeId !== 'number' &&
-            typeof maybeId !== 'boolean'
-        ) {
-            throw new Error(
-                `Expected resource '${resource.id}' of type '${resourceTypeHandle}' to have projection.id as string, number, or boolean`
-            );
-        }
-
-        const value = data as TValue;
-        const key = String(maybeId) as TKey;
-
-        out.set(key, value);
-    }
-
-    return out;
-}