@toolproof-core/lib 1.0.33 → 1.0.36

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

@@ -1,5 +1,5 @@
-import type { BranchStep, ForStep, Tool, ToolStep, WhileStep } from '@toolproof-core/schema';
-import { CONSTANTS } from '../../artifacts/artifacts.js';
+import type { BranchStep, ForStep, Tool, ToolStep, WhileStep } from '@toolproof-core/genesis';
+import { CONSTANTS } from '../../lookups/lookups.js';
 export declare function createToolStepFromTool(tool: Tool): ToolStep;
 export declare function createLoopStepFromToolPair(whatTool: Tool, whenTool: Tool, stepKind: typeof CONSTANTS.Enums.StepKind.for | typeof CONSTANTS.Enums.StepKind.while): ForStep | WhileStep;
 export declare function createBranchStepFromToolPairs(cases: Array<{
@@ -8,4 +8,3 @@ export declare function createBranchStepFromToolPairs(cases: Array<{
 }>): BranchStep;
 export declare function cloneForStep(forStep: ForStep): ForStep;
 export declare function cloneWhileStep(whileStep: WhileStep): WhileStep;
-//# sourceMappingURL=createStep.d.ts.map

package/dist/integrations/firebase/createStep.js

@@ -1,43 +1,17 @@
-import { CONSTANTS } from '../../artifacts/artifacts.js';
-import { buildBranchStepFromToolPairs, buildToolStepFromTool, buildLoopStepFromToolPair, cloneForStepWithIdentities, cloneWhileStepWithIdentities, } from '../../utils/creation/stepCreation.js';
-import { getNewStepId } from './firebaseAdminHelpers.js';
+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) {
-    return buildToolStepFromTool(tool, getNewStepId(CONSTANTS.Enums.StepKind.tool));
+    return buildToolStepFromTool(tool);
 }
 export function createLoopStepFromToolPair(whatTool, whenTool, stepKind) {
-    if (stepKind === CONSTANTS.Enums.StepKind.for) {
-        return buildLoopStepFromToolPair(whatTool, whenTool, {
-            stepKind,
-            stepId: getNewStepId(CONSTANTS.Enums.StepKind.for),
-            whatId: getNewStepId(CONSTANTS.Enums.StepKind.tool),
-            whenId: getNewStepId(CONSTANTS.Enums.StepKind.tool),
-        });
-    }
-    return buildLoopStepFromToolPair(whatTool, whenTool, {
-        stepKind,
-        stepId: getNewStepId(CONSTANTS.Enums.StepKind.while),
-        whatId: getNewStepId(CONSTANTS.Enums.StepKind.tool),
-        whenId: getNewStepId(CONSTANTS.Enums.StepKind.tool),
-    });
+    return buildLoopStepFromToolPair(whatTool, whenTool, stepKind);
 }
 export function createBranchStepFromToolPairs(cases) {
-    return buildBranchStepFromToolPairs(cases, getNewStepId(CONSTANTS.Enums.StepKind.branch), cases.map(() => ({
-        whatId: getNewStepId(CONSTANTS.Enums.StepKind.tool),
-        whenId: getNewStepId(CONSTANTS.Enums.StepKind.tool),
-    })));
+    return buildBranchStepFromToolPairs(cases);
 }
 export function cloneForStep(forStep) {
-    return cloneForStepWithIdentities(forStep, {
-        stepId: getNewStepId(CONSTANTS.Enums.StepKind.for),
-        whatId: getNewStepId(CONSTANTS.Enums.StepKind.tool),
-        whenId: getNewStepId(CONSTANTS.Enums.StepKind.tool),
-    });
+    return cloneForStepPure(forStep);
 }
 export function cloneWhileStep(whileStep) {
-    return cloneWhileStepWithIdentities(whileStep, {
-        stepId: getNewStepId(CONSTANTS.Enums.StepKind.while),
-        whatId: getNewStepId(CONSTANTS.Enums.StepKind.tool),
-        whenId: getNewStepId(CONSTANTS.Enums.StepKind.tool),
-    });
+    return cloneWhileStepPure(whileStep);
 }
-//# sourceMappingURL=createStep.js.map

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

@@ -0,0 +1,2 @@
+import { type ThreadableStrategy, type ThreadedStrategyLike } from '../../utils/creation/threadedStrategyCreation.js';
+export declare function createThreadedStrategy<TStrategyState>(strategy: ThreadableStrategy<TStrategyState>): ThreadedStrategyLike<TStrategyState>;

package/dist/integrations/firebase/createThreadedStrategy.js

@@ -0,0 +1,8 @@
+import { CONSTANTS } from '../../lookups/lookups.js';
+import { buildThreadedStrategy, getThreadedStrategyStepGroups, } from '../../utils/creation/threadedStrategyCreation.js';
+import { getNewId } from './firebaseAdminHelpers.js';
+export function createThreadedStrategy(strategy) {
+    const threadStepGroups = getThreadedStrategyStepGroups(strategy);
+    const strategyHandle = getNewId(CONSTANTS.Names.StrategyHandle);
+    return buildThreadedStrategy(threadStepGroups, strategyHandle, strategy);
+}

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

@@ -1,10 +1,4 @@
-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 { IdentifierName, IdentifierStringByName, ResourcesByType } from '../../types/types.js';
+export declare function getNewId<K extends IdentifierName>(identifierName: K): IdentifierStringByName<K>;
+export declare function listResources(resourceTypeHandles: ResourceTypeHandle[]): Promise<ResourcesByType>;

package/dist/integrations/firebase/firebaseAdminHelpers.js

@@ -1,154 +1,61 @@
-import { CONSTANTS, MAPPINGS } from '../../artifacts/artifacts.js';
+import { CONSTANTS, MAPPINGS } 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];
+export function getNewId(identifierName) {
+    const prefix = MAPPINGS.IdentifierNameToPrefix[identifierName];
     const docRef = dbAdmin
         .collection(CONSTANTS.Persistence.Collections.resources)
-        .doc(idName)
+        .doc(identifierName)
         .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) {
+export async function listResources(resourceTypeHandles) {
     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_RunnableStrategy
+    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,
+            };
+        });
+    }
+    async function fetchProjection(resourceTypeHandle, resourceId) {
+        const bucket = resourceTypeHandle === CONSTANTS.Handles.ResourceTypes.TYPE_Strategy
             ? bucketStrategies
             : bucketResources;
-        const prefix = `${resourceTypeId}/`;
-        const [found] = await bucket.getFiles({ prefix });
-        const files = found.filter((file) => {
-            const name = file.name || '';
-            return !!name && !name.endsWith('/');
-        });
-        if (!files.length) {
-            return [];
+        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 resourceRoleId = root.creationContext.resourceRoleId;
-            const toolStepId = root.creationContext.toolStepId;
-            const resourceShellKind = root.resourceShellKind;
-            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],
-                ['resourceRoleId', resourceRoleId],
-                ['toolStepId', toolStepId],
-                ['resourceShellKind', resourceShellKind],
-                ['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}`);
-            }
+    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,
-                creationContext: {
-                    resourceRoleId,
-                    toolStepId,
-                },
-                resourceShellKind,
-                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,221 @@
+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 Names: {
+        readonly AtomicTypeRef: "AtomicTypeRef";
+        readonly BaseResource: "BaseResource";
+        readonly BaseStrategy: "BaseStrategy";
+        readonly BaseToolStepPathSpec: "BaseToolStepPathSpec";
+        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 GraphEndTracePoint: "GraphEndTracePoint";
+        readonly GraphStartTracePoint: "GraphStartTracePoint";
+        readonly InputPotential: "InputPotential";
+        readonly InputResource: "InputResource";
+        readonly InternalInputPotential: "InternalInputPotential";
+        readonly InterruptTracePoint: "InterruptTracePoint";
+        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 StrategyHandle: "StrategyHandle";
+        readonly StrategyKind: "StrategyKind";
+        readonly StrategyProvenance: "StrategyProvenance";
+        readonly StrategyStateInputEntry: "StrategyStateInputEntry";
+        readonly StrategyStateInputEntryByRoleName: "StrategyStateInputEntryByRoleName";
+        readonly StrategyStateInputKind: "StrategyStateInputKind";
+        readonly StrategyTrace: "StrategyTrace";
+        readonly StrategyTraceHandle: "StrategyTraceHandle";
+        readonly Suite: "Suite";
+        readonly SuiteIngestorInputSchema: "SuiteIngestorInputSchema";
+        readonly ThreadedStrategy: "ThreadedStrategy";
+        readonly ThreadedStrategyFacet: "ThreadedStrategyFacet";
+        readonly ThreadedStrategyState: "ThreadedStrategyState";
+        readonly ThreadedStrategyStateFacet: "ThreadedStrategyStateFacet";
+        readonly ThreadedToolStepPath: "ThreadedToolStepPath";
+        readonly ThreadedToolStepPathSpec: "ThreadedToolStepPathSpec";
+        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 ToolStepRoleAddress: "ToolStepRoleAddress";
+        readonly TracePoint: "TracePoint";
+        readonly TracePointCounterSnapshot: "TracePointCounterSnapshot";
+        readonly TracePointDelta: "TracePointDelta";
+        readonly TracePointKind: "TracePointKind";
+        readonly TypeRef: "TypeRef";
+        readonly UnthreadedStrategy: "UnthreadedStrategy";
+        readonly UnthreadedStrategyState: "UnthreadedStrategyState";
+        readonly UnthreadedStrategyStateFacet: "UnthreadedStrategyStateFacet";
+        readonly UnthreadedToolStepPath: "UnthreadedToolStepPath";
+        readonly UnthreadedToolStepPathSpec: "UnthreadedToolStepPathSpec";
+        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 StrategyKind: {
+            readonly unthreaded: "unthreaded";
+            readonly threaded: "threaded";
+        };
+        readonly StrategyStateInputKind: {
+            readonly inputResource: "inputResource";
+            readonly externalInputPotential: "externalInputPotential";
+            readonly internalInputPotential: "internalInputPotential";
+        };
+        readonly TracePointKind: {
+            readonly graph_start: "graph_start";
+            readonly tick: "tick";
+            readonly interrupt: "interrupt";
+            readonly graph_end: "graph_end";
+        };
+    };
+};
+export declare const MAPPINGS: {
+    readonly IdentifierNameToPrefix: {
+        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,23 @@
+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',
+        },
+    },
+};
+export const MAPPINGS = {
+    ..._MAPPINGS,
+};

package/dist/types/types.d.ts

@@ -1,20 +1,16 @@
-import type { StepKind, Resource, ResourceTypeId } from '@toolproof-core/schema';
-import { CONSTANTS } from '../artifacts/artifacts.js';
-import { MAPPINGS } from '../artifacts/artifacts.js';
+import type { Resource, ResourceTypeHandle } from '@toolproof-core/genesis/types';
+import { CONSTANTS } from '../lookups/lookups.js';
+import { MAPPINGS } from '../lookups/lookups.js';
 export type Bucket = typeof CONSTANTS.Persistence.Buckets.tp_resources;
 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 interface NucleusBaseSmall<T extends string = string> {
+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 interface SmallBaseProjection<T extends string = string> {
     id: T;
 }
-export interface NucleusBaseLarge<T extends string = string> extends NucleusBaseSmall<T> {
+export interface LargeBaseProjection<T extends string = string> extends SmallBaseProjection<T> {
     name: string;
     description: string;
 }
-//# sourceMappingURL=types.d.ts.map

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/creation/resourceCreation.d.ts

@@ -1,21 +1,21 @@
-import type { CreationContext, ExternalInput, ReferenceInput, ResourceId, Resource, ResourceTypeId, StrategyRunId } from '@toolproof-core/schema';
+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;
-    resourceTypeId: ResourceTypeId;
-    creationContext: CreationContext;
-    strategyRunId?: StrategyRunId;
+    resourceTypeHandle: ResourceTypeHandle;
+    toolStepRoleAddress?: ToolStepRoleAddress;
+    strategyTraceHandle?: StrategyTraceHandle;
+    provenanceKind?: Provenance['provenanceKind'];
 }
-export type InputPotential = ReferenceInput & {
-    id: ResourceId;
-    resourceTypeId: ResourceTypeId;
-    creationContext: CreationContext;
-    strategyRunId?: StrategyRunId;
-};
-export declare function generatePath(resourceTypeId: ResourceTypeId, id: ResourceId): string;
-export declare function createMaterializedFromOutputPotential(outputPotential: OutputPotential, nucleus: unknown, timestamp?: string): Resource;
-export declare function createMaterializedFromInputPotential(inputPotential: InputPotential, nucleus: unknown, timestamp?: string): Resource;
-export declare function createMaterializedFromPotential(potential: InputPotential | OutputPotential, nucleus: unknown, timestamp?: string): Resource;
-export declare function createExternalInputPotential(_id: ResourceId, _resourceTypeId: ResourceTypeId): ExternalInput;
-export declare function createInputPotential(id: ResourceId, resourceTypeId: ResourceTypeId, creationContext: CreationContext): InputPotential;
-export declare function createOutputPotential(id: ResourceId, resourceTypeId: ResourceTypeId, creationContext: CreationContext): OutputPotential;
-//# sourceMappingURL=resourceCreation.d.ts.map
+export declare function createExternalInputPotential(): ExternalInputPotential;
+export declare function createInternalInputPotential(toolStepRoleAddress: ToolStepRoleAddress): InternalInputPotential;
+export declare function createStrategyProvenance(strategyTraceHandle: StrategyTraceHandle, toolStepRoleAddress: ToolStepRoleAddress): StrategyProvenance;
+export declare function createRuntimeProvenance(): RuntimeProvenance;
+export declare function createResourcePointer(id: ResourceId, resourceTypeHandle: ResourceTypeHandle, provenance: Provenance): ResourcePointer;
+export declare function createResource(resourcePointer: ResourcePointer, projection: unknown): Resource;
+export declare function createMaterializedFromOutputPotential(outputPotential: OutputPotential, projection: unknown): Resource;
+export declare function createMaterializedFromPotential(outputPotential: OutputPotential, projection: unknown): Resource;
+export declare function createOutputPotential(id: ResourceId, resourceTypeHandle: ResourceTypeHandle, toolStepRoleAddress?: ToolStepRoleAddress, strategyTraceHandle?: StrategyTraceHandle, provenanceKind?: Provenance['provenanceKind']): OutputPotential;
+export {};