@toolproof-core/lib 1.0.34 → 1.0.37

package/dist/integrations/firebase/firebaseAdminHelpers.d.ts

@@ -1,10 +1,3 @@
-import type { ResourceTypeId, StepKind } from '@toolproof-core/schema';
-import type { IdName, IdStringByIdName, ResourcesByType } from '../../types/types.js';
-type StepIdStringByStepKind<K extends StepKind> = string & {
-    readonly __stepKind?: K;
-};
-export declare function getNewId<K extends IdName>(idName: K): IdStringByIdName<K>;
-export declare function getNewStepId<K extends StepKind>(stepKind: K): StepIdStringByStepKind<K>;
-export declare function listResources(resourceTypeIds: ResourceTypeId[]): Promise<ResourcesByType>;
-export {};
-//# sourceMappingURL=firebaseAdminHelpers.d.ts.map
+import type { ResourceTypeHandle } from '@toolproof-core/genesis';
+import type { ResourcesByType } from '../../types/types.js';
+export declare function listResources(resourceTypeHandles: ResourceTypeHandle[]): Promise<ResourcesByType>;

package/dist/integrations/firebase/firebaseAdminHelpers.js

@@ -1,157 +1,52 @@
-import { CONSTANTS, MAPPINGS } from '../../artifacts/artifacts.js';
+import { CONSTANTS } from '../../lookups/lookups.js';
 import { dbAdmin, storageAdmin } from './firebaseAdminInit.js';
-function capitalizeFirst(value) {
-    if (!value) {
-        return value;
-    }
-    return value.charAt(0).toUpperCase() + value.slice(1);
-}
-export function getNewId(idName) {
-    const prefix = MAPPINGS.IdNameToIdPrefix[idName];
-    const docRef = dbAdmin
-        .collection(CONSTANTS.Persistence.Collections.resources)
-        .doc(idName)
-        .collection(CONSTANTS.Persistence.Collections.members)
-        .doc();
-    return (prefix + docRef.id);
-}
-export function getNewStepId(stepKind) {
-    const idName = `${capitalizeFirst(stepKind)}StepId`;
-    if (!(idName in MAPPINGS.IdNameToIdPrefix)) {
-        throw new Error(`No IdNameToIdPrefix entry for derived step id name: ${idName}`);
-    }
-    return getNewId(idName);
-}
-export async function listResources(resourceTypeIds) {
-    const bucketResources = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_resources);
-    const bucketStrategies = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_strategies);
-    async function fetchFilesUnder(resourceTypeId) {
-        const bucket = resourceTypeId === CONSTANTS.Cosmos.TYPE_ThreadedStrategy
-            ? bucketStrategies
-            : bucketResources;
-        const prefix = `${resourceTypeId}/`;
-        const [found] = await bucket.getFiles({ prefix });
-        const files = found.filter((file) => {
-            const name = file.name || '';
-            return !!name && !name.endsWith('/');
+export async function listResources(resourceTypeHandles) {
+    const resourcesBucket = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_resources);
+    const strategiesBucket = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_strategies);
+    async function fetchTimestampedMetadataUnder(resourceTypeHandle) {
+        const snapshot = await dbAdmin
+            .collection(CONSTANTS.Persistence.Collections.resources)
+            .doc(resourceTypeHandle)
+            .collection(CONSTANTS.Persistence.Collections.members)
+            .get();
+        return snapshot.docs.map((doc) => {
+            const data = doc.data();
+            if (typeof data.id !== 'string' ||
+                typeof data.resourceTypeHandle !== 'string' ||
+                !data.provenance ||
+                typeof data.provenance !== 'object' ||
+                typeof data.provenance.provenanceKind !== 'string') {
+                throw new Error(`Invalid TimestampedResource document for ${resourceTypeHandle}/${doc.id}`);
+            }
+            return {
+                id: data.id,
+                resourceTypeHandle: data.resourceTypeHandle,
+                provenance: data.provenance,
+            };
         });
-        if (!files.length) {
-            return [];
+    }
+    async function fetchProjection(resourceTypeHandle, resourceId) {
+        const bucket = resourceTypeHandle === CONSTANTS.Handles.ResourceTypes.TYPE_Strategy
+            ? strategiesBucket
+            : resourcesBucket;
+        const file = bucket.file(`${resourceTypeHandle}/${resourceId}`);
+        const [exists] = await file.exists();
+        if (!exists) {
+            throw new Error(`Missing projection blob for ${resourceTypeHandle}/${resourceId}`);
         }
-        const items = await Promise.all(files.map(async (file) => {
-            try {
-                const [buf] = await file.download();
-                const meta = file.metadata || (await file.getMetadata())[0];
-                const data = JSON.parse(buf.toString('utf8'));
-                return { data, meta, name: file.name };
-            }
-            catch {
-                return null;
-            }
-        }));
-        return items.filter(Boolean);
+        const [buf] = await file.download();
+        return JSON.parse(buf.toString('utf8'));
     }
-    const entries = await Promise.all(resourceTypeIds.map(async (resourceTypeId) => {
-        const rows = await fetchFilesUnder(resourceTypeId);
-        const items = rows.map(({ data, meta, name }) => {
-            const flat = meta?.metadata ?? {};
-            const root = {};
-            for (const [key, valueRaw] of Object.entries(flat)) {
-                if (typeof valueRaw !== 'string') {
-                    continue;
-                }
-                const valueString = valueRaw.trim();
-                let value = valueString;
-                if ((valueString.startsWith('{') && valueString.endsWith('}')) || (valueString.startsWith('[') && valueString.endsWith(']'))) {
-                    try {
-                        value = JSON.parse(valueString);
-                    }
-                    catch {
-                        value = valueString;
-                    }
-                }
-                const segments = key.split('.');
-                let cursor = root;
-                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;
-                        }
-                        const idx = parseInt(idxStr, 10);
-                        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] = {};
-                            }
-                            cursor = cursor[base][idx];
-                        }
-                    }
-                    else {
-                        if (index === segments.length - 1) {
-                            cursor[segment] = value;
-                        }
-                        else {
-                            if (!cursor[segment] || typeof cursor[segment] !== 'object') {
-                                cursor[segment] = {};
-                            }
-                            cursor = cursor[segment];
-                        }
-                    }
-                }
-            }
-            const id = root.id;
-            const provenance = root.provenance;
-            const versionRaw = root.version;
-            const version = typeof versionRaw === 'number'
-                ? versionRaw
-                : parseInt(String(versionRaw ?? ''), 10);
-            const resourcePath = root.path;
-            const timestamp = root.timestamp;
-            const missing = [
-                ['id', id],
-                ['version', Number.isFinite(version) ? String(version) : ''],
-                ['timestamp', timestamp],
-                ['path', resourcePath],
-            ].filter(([_, value]) => typeof value !== 'string' || value.length === 0);
-            if (missing.length) {
-                const keys = missing.map(([key]) => key).join(', ');
-                throw new Error(`Missing required metadata keys [${keys}] for resource file: ${name}`);
-            }
-            if (!provenance || typeof provenance !== 'object' || typeof provenance.resourceProvenanceKind !== 'string') {
-                throw new Error(`Missing required metadata key [provenance] for resource file: ${name}`);
-            }
-            if (provenance.resourceProvenanceKind === 'strategy') {
-                const creationContext = provenance.creationContext;
-                if (!creationContext ||
-                    typeof creationContext !== 'object' ||
-                    typeof creationContext.roleName !== 'string' ||
-                    typeof creationContext.toolStepPath !== 'string') {
-                    throw new Error(`Missing required strategy provenance creationContext for resource file: ${name}`);
-                }
-            }
+    const entries = await Promise.all(resourceTypeHandles.map(async (resourceTypeHandle) => {
+        const pointers = await fetchTimestampedMetadataUnder(resourceTypeHandle);
+        const items = await Promise.all(pointers.map(async (resourcePointer) => {
+            const projection = await fetchProjection(resourceTypeHandle, resourcePointer.id);
             return {
-                id,
-                resourceTypeId,
-                provenance,
-                version,
-                timestamp: timestamp,
-                path: resourcePath,
-                nucleus: data,
+                ...resourcePointer,
+                projection,
             };
-        });
-        return [resourceTypeId, items];
+        }));
+        return [resourceTypeHandle, items];
     }));
     return Object.fromEntries(entries);
 }
-//# sourceMappingURL=firebaseAdminHelpers.js.map

package/dist/integrations/firebase/firebaseAdminInit.d.ts

@@ -1,4 +1,3 @@
 declare const dbAdmin: FirebaseFirestore.Firestore;
 declare const storageAdmin: import("firebase-admin/storage").Storage;
 export { dbAdmin, storageAdmin };
-//# sourceMappingURL=firebaseAdminInit.d.ts.map

package/dist/integrations/firebase/firebaseAdminInit.js

@@ -30,4 +30,3 @@ const app = getApps().length ? getApp() : initializeApp({
 const dbAdmin = getFirestore(app);
 const storageAdmin = getStorage(app);
 export { dbAdmin, storageAdmin };
-//# sourceMappingURL=firebaseAdminInit.js.map

package/dist/lookups/lookups.d.ts

@@ -0,0 +1,214 @@
+export declare const CONSTANTS: {
+    readonly Persistence: {
+        readonly Buckets: {
+            readonly tp_resources: "tp-resources";
+            readonly tp_strategies: "tp-strategies";
+        };
+        readonly Collections: {
+            readonly resources: "resources";
+            readonly members: "members";
+        };
+    };
+    readonly Engine: {
+        readonly Graphs: {
+            readonly GraphRunStrategy: "GraphRunStrategy";
+            readonly GraphBuildStrategy: "GraphBuildStrategy";
+        };
+    };
+    readonly Cosmos: {
+        readonly ErrorOutputRoleName: "ErrorOutput";
+    };
+    readonly Names: {
+        readonly AtomicTypeRef: "AtomicTypeRef";
+        readonly BaseResource: "BaseResource";
+        readonly BaseTracePoint: "BaseTracePoint";
+        readonly Boolean: "Boolean";
+        readonly BranchStep: "BranchStep";
+        readonly Case: "Case";
+        readonly ContainerKind: "ContainerKind";
+        readonly Description: "Description";
+        readonly DescriptionFacet: "DescriptionFacet";
+        readonly DocumentationSpec: "DocumentationSpec";
+        readonly Embedding: "Embedding";
+        readonly Error: "Error";
+        readonly ExternalInputPotential: "ExternalInputPotential";
+        readonly ForStep: "ForStep";
+        readonly GenesisProvenance: "GenesisProvenance";
+        readonly Goal: "Goal";
+        readonly GoalHandle: "GoalHandle";
+        readonly InputPotential: "InputPotential";
+        readonly InputResource: "InputResource";
+        readonly InternalInputPotential: "InternalInputPotential";
+        readonly JsonScalarLink: "JsonScalarLink";
+        readonly JsonSchemaObject: "JsonSchemaObject";
+        readonly Name: "Name";
+        readonly NameFacet: "NameFacet";
+        readonly Natural: "Natural";
+        readonly Provenance: "Provenance";
+        readonly ProvenanceFacet: "ProvenanceFacet";
+        readonly ProvenanceKind: "ProvenanceKind";
+        readonly Resource: "Resource";
+        readonly ResourceId: "ResourceId";
+        readonly ResourcePointer: "ResourcePointer";
+        readonly ResourceType: "ResourceType";
+        readonly ResourceTypeHandle: "ResourceTypeHandle";
+        readonly RoleBindingSpec: "RoleBindingSpec";
+        readonly RoleBindingSpecFacet: "RoleBindingSpecFacet";
+        readonly RoleName: "RoleName";
+        readonly RoleNameArray: "RoleNameArray";
+        readonly RoleSpec: "RoleSpec";
+        readonly RoleSpecFacet: "RoleSpecFacet";
+        readonly RoleValue: "RoleValue";
+        readonly RoleValueByName: "RoleValueByName";
+        readonly RuntimeProvenance: "RuntimeProvenance";
+        readonly Step: "Step";
+        readonly StepArray: "StepArray";
+        readonly StepArrayArray: "StepArrayArray";
+        readonly StepKind: "StepKind";
+        readonly StepKindFacet: "StepKindFacet";
+        readonly StepsByThreadIndexFacet: "StepsByThreadIndexFacet";
+        readonly StepsFacet: "StepsFacet";
+        readonly Strategy: "Strategy";
+        readonly StrategyEndTracePoint: "StrategyEndTracePoint";
+        readonly StrategyFacet: "StrategyFacet";
+        readonly StrategyHandle: "StrategyHandle";
+        readonly StrategyProvenance: "StrategyProvenance";
+        readonly StrategyStartTracePoint: "StrategyStartTracePoint";
+        readonly StrategyState: "StrategyState";
+        readonly StrategyStateFacet: "StrategyStateFacet";
+        readonly StrategyStateInputEntry: "StrategyStateInputEntry";
+        readonly StrategyStateInputEntryByRoleName: "StrategyStateInputEntryByRoleName";
+        readonly StrategyStateInputKind: "StrategyStateInputKind";
+        readonly StrategyTrace: "StrategyTrace";
+        readonly StrategyTraceHandle: "StrategyTraceHandle";
+        readonly Suite: "Suite";
+        readonly SuiteIngestorInputSchema: "SuiteIngestorInputSchema";
+        readonly SuspendedTracePoint: "SuspendedTracePoint";
+        readonly TickTracePoint: "TickTracePoint";
+        readonly TimestampedResource: "TimestampedResource";
+        readonly Tool: "Tool";
+        readonly ToolHandle: "ToolHandle";
+        readonly ToolStep: "ToolStep";
+        readonly ToolStepPath: "ToolStepPath";
+        readonly ToolStepPathSlot: "ToolStepPathSlot";
+        readonly ToolStepPathSlotFacet: "ToolStepPathSlotFacet";
+        readonly ToolStepPathSpec: "ToolStepPathSpec";
+        readonly ToolStepRoleAddress: "ToolStepRoleAddress";
+        readonly TracePoint: "TracePoint";
+        readonly TracePointCounterSnapshot: "TracePointCounterSnapshot";
+        readonly TracePointDelta: "TracePointDelta";
+        readonly TracePointKind: "TracePointKind";
+        readonly TypeRef: "TypeRef";
+        readonly WhileStep: "WhileStep";
+    };
+    readonly Handles: {
+        readonly ResourceTypes: {
+            readonly TYPE_Boolean: "TYPE-Boolean";
+            readonly TYPE_Error: "TYPE-Error";
+            readonly TYPE_Goal: "TYPE-Goal";
+            readonly TYPE_Natural: "TYPE-Natural";
+            readonly TYPE_Resource: "TYPE-Resource";
+            readonly TYPE_ResourceType: "TYPE-ResourceType";
+            readonly TYPE_Strategy: "TYPE-Strategy";
+            readonly TYPE_StrategyTrace: "TYPE-StrategyTrace";
+            readonly TYPE_Suite: "TYPE-Suite";
+            readonly TYPE_Tool: "TYPE-Tool";
+        };
+        readonly Tools: {
+            readonly TOOL_Add: "TOOL-Add";
+            readonly TOOL_BooleanIdentity: "TOOL-BooleanIdentity";
+            readonly TOOL_Divide: "TOOL-Divide";
+            readonly TOOL_Double: "TOOL-Double";
+            readonly TOOL_Identity: "TOOL-Identity";
+            readonly TOOL_LessThan: "TOOL-LessThan";
+            readonly TOOL_Multiply: "TOOL-Multiply";
+            readonly TOOL_NaturalAdd: "TOOL-NaturalAdd";
+            readonly TOOL_NaturalDivide: "TOOL-NaturalDivide";
+            readonly TOOL_NaturalDouble: "TOOL-NaturalDouble";
+            readonly TOOL_NaturalIdentity: "TOOL-NaturalIdentity";
+            readonly TOOL_NaturalLessThan: "TOOL-NaturalLessThan";
+            readonly TOOL_NaturalMultiply: "TOOL-NaturalMultiply";
+            readonly TOOL_NaturalSubtract: "TOOL-NaturalSubtract";
+            readonly TOOL_Subtract: "TOOL-Subtract";
+        };
+    };
+    readonly ToolRoleNames: {
+        readonly TOOL_Add: {
+            readonly AddendOne: "AddendOne";
+            readonly AddendTwo: "AddendTwo";
+            readonly Sum: "Sum";
+        };
+        readonly TOOL_Divide: {
+            readonly Dividend: "Dividend";
+            readonly Divisor: "Divisor";
+            readonly Quotient: "Quotient";
+            readonly Remainder: "Remainder";
+        };
+        readonly TOOL_Double: {
+            readonly Doubled: "Doubled";
+            readonly N: "N";
+        };
+        readonly TOOL_Identity: {
+            readonly In: "In";
+            readonly Out: "Out";
+        };
+        readonly TOOL_LessThan: {
+            readonly LessThanDecision: "LessThanDecision";
+            readonly LessThanSource: "LessThanSource";
+            readonly LessThanTarget: "LessThanTarget";
+        };
+        readonly TOOL_Multiply: {
+            readonly Multiplicand: "Multiplicand";
+            readonly Multiplier: "Multiplier";
+            readonly Product: "Product";
+        };
+        readonly TOOL_Subtract: {
+            readonly Difference: "Difference";
+            readonly Minuend: "Minuend";
+            readonly Subtrahend: "Subtrahend";
+        };
+    };
+    readonly Enums: {
+        readonly ContainerKind: {
+            readonly scalar: "scalar";
+            readonly array: "array";
+            readonly map: "map";
+        };
+        readonly ProvenanceKind: {
+            readonly genesis: "genesis";
+            readonly runtime: "runtime";
+            readonly strategy: "strategy";
+        };
+        readonly StepKind: {
+            readonly tool: "tool";
+            readonly branch: "branch";
+            readonly while: "while";
+            readonly for: "for";
+        };
+        readonly StrategyStateInputKind: {
+            readonly inputResource: "inputResource";
+            readonly externalInputPotential: "externalInputPotential";
+            readonly internalInputPotential: "internalInputPotential";
+        };
+        readonly TracePointKind: {
+            readonly strategy_start: "strategy_start";
+            readonly tick: "tick";
+            readonly suspended: "suspended";
+            readonly strategy_end: "strategy_end";
+        };
+    };
+};
+export declare const MAPPINGS: {
+    readonly IdentifierNameToPrefix: {
+        readonly ToolStepKey: "TOOL_STEP-";
+        readonly BranchStepKey: "BRANCH_STEP-";
+        readonly WhileStepKey: "WHILE_STEP-";
+        readonly ForStepKey: "FOR_STEP-";
+        readonly GoalHandle: "GOAL-";
+        readonly ResourceId: "RESOURCE-";
+        readonly ResourceTypeHandle: "TYPE-";
+        readonly StrategyHandle: "STRATEGY-";
+        readonly StrategyTraceHandle: "STRATEGY_TRACE-";
+        readonly ToolHandle: "TOOL-";
+    };
+};

package/dist/lookups/lookups.js

@@ -0,0 +1,33 @@
+import { CONSTANTS as _CONSTANTS, MAPPINGS as _MAPPINGS } from '@toolproof-core/genesis';
+export const CONSTANTS = {
+    ..._CONSTANTS,
+    Persistence: {
+        Buckets: {
+            tp_resources: 'tp-resources',
+            tp_strategies: 'tp-strategies',
+        },
+        Collections: {
+            resources: 'resources',
+            members: 'members',
+        },
+    },
+    Engine: {
+        Graphs: {
+            GraphRunStrategy: 'GraphRunStrategy',
+            GraphBuildStrategy: 'GraphBuildStrategy',
+        },
+    },
+    Cosmos: {
+        ErrorOutputRoleName: 'ErrorOutput',
+    }
+};
+export const MAPPINGS = {
+    ..._MAPPINGS,
+    IdentifierNameToPrefix: {
+        ..._MAPPINGS.IdentifierNameToPrefix,
+        ToolStepKey: 'TOOL_STEP-',
+        BranchStepKey: 'BRANCH_STEP-',
+        WhileStepKey: 'WHILE_STEP-',
+        ForStepKey: 'FOR_STEP-',
+    },
+};

package/dist/types/types.d.ts

@@ -1,20 +1,20 @@
-import type { StepKind, Resource, ResourceTypeId } from '@toolproof-core/schema';
-import { CONSTANTS } from '../artifacts/artifacts.js';
-import { MAPPINGS } from '../artifacts/artifacts.js';
-export type Bucket = typeof CONSTANTS.Persistence.Buckets.tp_resources;
+import type { Resource, ResourceTypeHandle } from '@toolproof-core/genesis/types';
+import { CONSTANTS } from '../lookups/lookups.js';
+import { MAPPINGS } from '../lookups/lookups.js';
+export type Bucket = keyof typeof CONSTANTS.Persistence.Buckets;
 export type Collection = keyof typeof CONSTANTS.Persistence.Collections;
 export type SchemaLike = Record<string, unknown>;
-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 StepKind> = string & {
-    readonly __stepKind?: K;
+export type ResourcesByType = Record<ResourceTypeHandle, Resource[]>;
+export type IdentifierName = keyof typeof MAPPINGS.IdentifierNameToPrefix;
+export type IdentifierStringByName<K extends IdentifierName> = `${(typeof MAPPINGS.IdentifierNameToPrefix)[K]}${string}`;
+export type ItemKey = string;
+export type BaseItem = {
+    itemKey: ItemKey;
 };
-export interface NucleusBaseSmall<T extends string = string> {
-    id: T;
-}
-export interface NucleusBaseLarge<T extends string = string> extends NucleusBaseSmall<T> {
+export type DocumentedBaseItem = BaseItem & {
     name: string;
     description: string;
-}
-//# sourceMappingURL=types.d.ts.map
+};
+export type Item = DocumentedBaseItem & {
+    label: string;
+};

package/dist/types/types.js

@@ -1,3 +1,2 @@
-import { CONSTANTS } from '../artifacts/artifacts.js';
-import { MAPPINGS } from '../artifacts/artifacts.js';
-//# sourceMappingURL=types.js.map
+import { CONSTANTS } from '../lookups/lookups.js';
+import { MAPPINGS } from '../lookups/lookups.js';

package/dist/utils/cosmosDataExtraction.d.ts

@@ -0,0 +1,5 @@
+import type { Resource, TimestampedResource } from '@toolproof-core/genesis';
+export declare function timestampedResourceToResource(timestampedResource: TimestampedResource): Resource;
+export declare function extractProjectionMapByHandle<TKey extends string, TProjection extends {
+    handle: TKey;
+}>(resources: Resource[] | undefined): Map<TKey, TProjection>;

package/dist/utils/cosmosDataExtraction.js

@@ -0,0 +1,15 @@
+export function timestampedResourceToResource(timestampedResource) {
+    const { timestamp: _timestamp, ...resource } = timestampedResource;
+    return resource;
+}
+export function extractProjectionMapByHandle(resources) {
+    const map = new Map();
+    for (const resource of resources ?? []) {
+        const projection = resource.projection;
+        if (!projection || typeof projection !== 'object' || !projection.handle) {
+            continue;
+        }
+        map.set(projection.handle, projection);
+    }
+    return map;
+}

package/dist/utils/identifierGeneration.d.ts

@@ -0,0 +1,2 @@
+import type { IdentifierName, IdentifierStringByName } from '../types/types.js';
+export declare function generateIdentifier<K extends IdentifierName>(identifierName: K): IdentifierStringByName<K>;

package/dist/utils/identifierGeneration.js

@@ -0,0 +1,5 @@
+import { MAPPINGS } from '../lookups/lookups.js';
+export function generateIdentifier(identifierName) {
+    const prefix = MAPPINGS.IdentifierNameToPrefix[identifierName];
+    return (prefix + crypto.randomUUID());
+}

package/dist/utils/mutableStrategyOverlay.d.ts

@@ -0,0 +1,55 @@
+import type { BranchStep, Case, ExternalInputPotential, ForStep, InputResource, InternalInputPotential, Resource, RoleName, Strategy, Tool, ToolHandle, ToolStep, ToolStepRoleAddress, WhileStep } from '@toolproof-core/genesis';
+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 declare function getAuthoringSteps<TKey extends string = MutableToolStepKey, TStep extends MutableStep<TKey> = MutableStep<TKey>, TState extends MutableStrategyState<TKey> = MutableStrategyState<TKey>>(strategy: MutableStrategy<TKey, TStep, TState>): TStep[];
+export declare 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>;
+export declare function getStrategyStateInputEntryByRoleName<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepKey: TKey): MutableStrategyStateInputEntryByRoleName<TKey> | undefined;
+export declare function getStrategyStateInputEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress<TKey>): MutableStrategyStateInputEntry<TKey> | undefined;
+export declare function setStrategyStateInputEntry<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress<TKey>, entry: MutableStrategyStateInputEntry<TKey>): TStrategyState;
+export declare function clearInputBinding<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, toolStepRoleAddress: MutableToolStepRoleAddress<TKey>): TStrategyState;
+export declare function bindInputResource<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, target: MutableToolStepRoleAddress<TKey>, resource: Resource): TStrategyState;
+export declare 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;
+export declare function bindExternalInputPotential<TKey extends string, TStrategyState extends MutableStrategyState<TKey>>(strategyState: TStrategyState, target: MutableToolStepRoleAddress<TKey>): TStrategyState;