@toolproof-core/lib 1.0.33 → 1.0.36

package/dist/utils/roleSpec.d.ts

@@ -1,4 +1,9 @@
-import type { RoleName, RoleValue, Strategy, Tool, ToolStep } from '@toolproof-core/schema';
+import type { RoleName, RoleValue, Step, StepArrayArray, Tool, ToolStep } from '@toolproof-core/genesis';
+export type StrategyStepGraph = {
+    steps: Step[];
+} | {
+    stepsByThreadIndex: StepArrayArray;
+};
 export interface ToolRoleDescriptor extends RoleValue {
     id: RoleName;
     name: string;
@@ -8,5 +13,4 @@ export declare function getOutputRoleEntries(tool: Tool): Array<[RoleName, RoleV
 export declare function getInputRoleNames(tool: Tool): RoleName[];
 export declare function getOutputRoleNames(tool: Tool): RoleName[];
 export declare function toToolRoleDescriptor([roleName, roleValue]: [RoleName, RoleValue]): ToolRoleDescriptor;
-export declare function extractToolStepsFromStrategy(strategy: Strategy): ToolStep[];
-//# sourceMappingURL=roleSpec.d.ts.map
+export declare function extractToolStepsFromStrategy(strategy: StrategyStepGraph): ToolStep[];

package/dist/utils/roleSpec.js

@@ -55,4 +55,3 @@ export function extractToolStepsFromStrategy(strategy) {
     }
     return toolSteps;
 }
-//# sourceMappingURL=roleSpec.js.map

package/dist/utils/strategyState.d.ts

@@ -1,7 +1,12 @@
-import type { CreationContext, Strategy, StrategyStateInputEntry, StrategyStateInputEntryByRoleName } from '@toolproof-core/schema';
+import type { ToolStepRoleAddress, ToolStepPath, Resource, Strategy, StrategyStateInputEntry, StrategyStateInputEntryByRoleName, ThreadedStrategyState, ThreadedToolStepPath, ThreadedToolStepRoleAddress, UnthreadedStrategyState, UnthreadedToolStepPath, UnthreadedToolStepRoleAddress } from '@toolproof-core/genesis';
 export type StrategyState = Strategy['strategyState'];
-export declare function getStrategyStateBucket(strategyState: StrategyState, toolStepPath: CreationContext['toolStepPath']): StrategyStateInputEntryByRoleName | undefined;
-export declare function getStrategyStateEntry(strategyState: StrategyState, context: CreationContext): StrategyStateInputEntry | undefined;
-export declare function setStrategyStateEntry(strategyState: StrategyState, context: CreationContext, entry: StrategyStateInputEntry): StrategyState;
-export declare function clearStrategyStateEntry(strategyState: StrategyState, context: CreationContext): StrategyState;
-//# sourceMappingURL=strategyState.d.ts.map
+type ToolStepPathForStrategyState<TStrategyState extends StrategyState> = TStrategyState extends UnthreadedStrategyState ? UnthreadedToolStepPath : TStrategyState extends ThreadedStrategyState ? ThreadedToolStepPath : ToolStepPath;
+type ToolStepRoleAddressForStrategyState<TStrategyState extends StrategyState> = TStrategyState extends UnthreadedStrategyState ? UnthreadedToolStepRoleAddress : TStrategyState extends ThreadedStrategyState ? ThreadedToolStepRoleAddress : ToolStepRoleAddress;
+export declare function getStrategyStateBucket<TStrategyState extends StrategyState>(strategyState: TStrategyState, toolStepPath: ToolStepPathForStrategyState<TStrategyState>): StrategyStateInputEntryByRoleName | undefined;
+export declare function getStrategyStateEntry<TStrategyState extends StrategyState>(strategyState: TStrategyState, toolStepRoleAddress: ToolStepRoleAddressForStrategyState<TStrategyState>): StrategyStateInputEntry | undefined;
+export declare function setStrategyStateEntry<TStrategyState extends StrategyState>(strategyState: TStrategyState, toolStepRoleAddress: ToolStepRoleAddressForStrategyState<TStrategyState>, entry: StrategyStateInputEntry): TStrategyState;
+export declare function clearStrategyStateEntry<TStrategyState extends StrategyState>(strategyState: TStrategyState, toolStepRoleAddress: ToolStepRoleAddressForStrategyState<TStrategyState>): TStrategyState;
+export declare function bindInputResource<TStrategyState extends StrategyState>(strategyState: TStrategyState, target: ToolStepRoleAddressForStrategyState<TStrategyState>, resource: Resource): TStrategyState;
+export declare function bindInternalInputPotential<TStrategyState extends StrategyState>(strategyState: TStrategyState, target: ToolStepRoleAddressForStrategyState<TStrategyState>, source: ToolStepRoleAddressForStrategyState<TStrategyState>): TStrategyState;
+export declare function bindExternalInputPotential<TStrategyState extends StrategyState>(strategyState: TStrategyState, target: ToolStepRoleAddressForStrategyState<TStrategyState>): TStrategyState;
+export {};

package/dist/utils/strategyState.js

@@ -1,29 +1,58 @@
 export function getStrategyStateBucket(strategyState, toolStepPath) {
     return strategyState[toolStepPath];
 }
-export function getStrategyStateEntry(strategyState, context) {
-    return getStrategyStateBucket(strategyState, context.toolStepPath)?.[context.roleName];
+export function getStrategyStateEntry(strategyState, toolStepRoleAddress) {
+    const toolStepPath = toolStepRoleAddress.toolStepPath;
+    return getStrategyStateBucket(strategyState, toolStepPath)?.[toolStepRoleAddress.roleName];
 }
-export function setStrategyStateEntry(strategyState, context, entry) {
-    const bucket = getStrategyStateBucket(strategyState, context.toolStepPath) ?? {};
+export function setStrategyStateEntry(strategyState, toolStepRoleAddress, entry) {
+    const toolStepPath = toolStepRoleAddress.toolStepPath;
+    const bucket = getStrategyStateBucket(strategyState, toolStepPath) ?? {};
     return {
         ...strategyState,
-        [context.toolStepPath]: {
+        [toolStepPath]: {
             ...bucket,
-            [context.roleName]: entry,
+            [toolStepRoleAddress.roleName]: entry,
         },
     };
 }
-export function clearStrategyStateEntry(strategyState, context) {
-    const bucket = getStrategyStateBucket(strategyState, context.toolStepPath);
-    if (!bucket || !(context.roleName in bucket)) {
+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[context.roleName];
+    delete nextBucket[toolStepRoleAddress.roleName];
     return {
         ...strategyState,
-        [context.toolStepPath]: nextBucket,
+        [toolStepPath]: nextBucket,
     };
 }
-//# sourceMappingURL=strategyState.js.map
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,12 @@
+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/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@toolproof-core/lib",
-  "version": "1.0.33",
+  "version": "1.0.36",
   "description": "",
   "type": "module",
   "keywords": [],
   "author": "",
   "license": "ISC",
   "exports": {
-    "./artifacts": {
-      "types": "./dist/artifacts/artifacts.d.ts",
-      "import": "./dist/artifacts/artifacts.js"
+    "./lookups": {
+      "types": "./dist/lookups/lookups.d.ts",
+      "import": "./dist/lookups/lookups.js"
     },
     "./types": {
       "types": "./dist/types/types.d.ts",
@@ -27,17 +27,17 @@
       "types": "./dist/integrations/firebase/createStep.d.ts",
       "import": "./dist/integrations/firebase/createStep.js"
     },
-    "./create-runnable-strategy": {
-      "types": "./dist/integrations/firebase/createRunnableStrategy.d.ts",
-      "import": "./dist/integrations/firebase/createRunnableStrategy.js"
+    "./create-threaded-strategy": {
+      "types": "./dist/integrations/firebase/createThreadedStrategy.d.ts",
+      "import": "./dist/integrations/firebase/createThreadedStrategy.js"
     },
-    "./resolve-resource-chain": {
-      "types": "./dist/utils/resolveResourceChain.d.ts",
-      "import": "./dist/utils/resolveResourceChain.js"
+    "./resolve-strategy-state-chain": {
+      "types": "./dist/utils/resolveStrategyStateChain.d.ts",
+      "import": "./dist/utils/resolveStrategyStateChain.js"
     },
-    "./bind-input-role-to-resource": {
-      "types": "./dist/utils/bindInputRoleToResource.d.ts",
-      "import": "./dist/utils/bindInputRoleToResource.js"
+    "./strategy-state": {
+      "types": "./dist/utils/strategyState.d.ts",
+      "import": "./dist/utils/strategyState.js"
     },
     "./firebase-admin-init": {
       "types": "./dist/integrations/firebase/firebaseAdminInit.d.ts",
@@ -52,8 +52,8 @@
     "@types/node": "^22.0.0"
   },
   "dependencies": {
-    "@toolproof-core/schema": "^1.0.46",
-    "firebase-admin": "^13.7.0"
+    "firebase-admin": "^13.7.0",
+    "@toolproof-core/genesis": "1.0.56"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",

package/src/integrations/firebase/createStep.ts

@@ -4,19 +4,18 @@ import type {
     Tool,
     ToolStep,
     WhileStep,
-} from '@toolproof-core/schema';
-import { CONSTANTS } from '../../artifacts/artifacts.js';
+} from '@toolproof-core/genesis';
+import { CONSTANTS } from '../../lookups/lookups.js';
 import {
     buildBranchStepFromToolPairs,
     buildToolStepFromTool,
     buildLoopStepFromToolPair,
-    cloneForStepWithIdentities,
-    cloneWhileStepWithIdentities,
+    cloneForStep as cloneForStepPure,
+    cloneWhileStep as cloneWhileStepPure,
 } from '../../utils/creation/stepCreation.js';
-import { getNewStepId } from './firebaseAdminHelpers.js';
 
 export function createToolStepFromTool(tool: Tool): ToolStep {
-    return buildToolStepFromTool(tool, getNewStepId(CONSTANTS.Enums.StepKind.tool));
+    return buildToolStepFromTool(tool);
 }
 
 export function createLoopStepFromToolPair(
@@ -24,48 +23,19 @@ export function createLoopStepFromToolPair(
     whenTool: Tool,
     stepKind: typeof CONSTANTS.Enums.StepKind.for | typeof CONSTANTS.Enums.StepKind.while,
 ): ForStep | WhileStep {
-    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: Array<{ whatTool: Tool; whenTool: Tool }>,
 ): BranchStep {
-    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: ForStep): 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: WhileStep): 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);
 }

package/src/integrations/firebase/createThreadedStrategy.ts

@@ -0,0 +1,19 @@
+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/integrations/firebase/firebaseAdminHelpers.ts

@@ -1,194 +1,92 @@
 import type {
     Resource,
-    ResourceTypeId,
-    StepKind,
-} from '@toolproof-core/schema';
+    ResourcePointer,
+    ResourceTypeHandle,
+    TimestampedResource,
+} from '@toolproof-core/genesis';
 import type {
-    IdName,
-    IdStringByIdName,
+    IdentifierName,
+    IdentifierStringByName,
     ResourcesByType,
 } from '../../types/types.js';
-import { CONSTANTS, MAPPINGS } from '../../artifacts/artifacts.js';
+import { CONSTANTS, MAPPINGS } from '../../lookups/lookups.js';
 import { dbAdmin, storageAdmin } from './firebaseAdminInit.js';
 
-type StepIdStringByStepKind<K extends StepKind> = string & { readonly __stepKind?: K };
-
-function capitalizeFirst(value: string): string {
-    if (!value) {
-        return value;
-    }
-
-    return value.charAt(0).toUpperCase() + value.slice(1);
-}
-
-export function getNewId<K extends IdName>(idName: K): IdStringByIdName<K> {
-    const prefix = MAPPINGS.IdNameToIdPrefix[idName];
+export function getNewId<K extends IdentifierName>(identifierName: K): IdentifierStringByName<K> {
+    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) as IdStringByIdName<K>;
-}
-
-export function getNewStepId<K extends StepKind>(stepKind: K): StepIdStringByStepKind<K> {
-    const idName = `${capitalizeFirst(stepKind)}StepId` as IdName;
-
-    if (!(idName in MAPPINGS.IdNameToIdPrefix)) {
-        throw new Error(`No IdNameToIdPrefix entry for derived step id name: ${idName}`);
-    }
-
-    return getNewId(idName) as StepIdStringByStepKind<K>;
+    return (prefix + docRef.id) as IdentifierStringByName<K>;
 }
 
 export async function listResources(
-    resourceTypeIds: ResourceTypeId[],
+    resourceTypeHandles: ResourceTypeHandle[],
 ): Promise<ResourcesByType> {
     const bucketResources = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_resources);
     const bucketStrategies = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_strategies);
 
-    async function fetchFilesUnder(
-        resourceTypeId: ResourceTypeId,
-    ): Promise<Array<{ data: unknown; meta: any; name: string }>> {
-        const bucket = resourceTypeId === CONSTANTS.Cosmos.TYPE_RunnableStrategy
-            ? bucketStrategies
-            : bucketResources;
-        const prefix = `${resourceTypeId}/`;
-        const [found] = await bucket.getFiles({ prefix });
-        const files = found.filter((file) => {
-            const name = file.name || '';
-            return !!name && !name.endsWith('/');
+    async function fetchTimestampedMetadataUnder(
+        resourceTypeHandle: ResourceTypeHandle,
+    ): Promise<ResourcePointer[]> {
+        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() as Partial<TimestampedResource>;
+            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,
+            } as ResourcePointer;
         });
+    }
 
-        if (!files.length) {
-            return [];
+    async function fetchProjection(
+        resourceTypeHandle: ResourceTypeHandle,
+        resourceId: ResourcePointer['id'],
+    ): Promise<unknown> {
+        const bucket = resourceTypeHandle === CONSTANTS.Handles.ResourceTypes.TYPE_Strategy
+            ? bucketStrategies
+            : bucketResources;
+        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')) as unknown;
-                return { data, meta, name: file.name };
-            } catch {
-                return null as unknown as { data: unknown; meta: any; name: string };
-            }
-        }));
-
-        return items.filter(Boolean) as Array<{ data: unknown; meta: any; name: string }>;
+        const [buf] = await file.download();
+        return JSON.parse(buf.toString('utf8')) as unknown;
     }
 
     const entries = await Promise.all(
-        resourceTypeIds.map(async (resourceTypeId) => {
-            const rows = await fetchFilesUnder(resourceTypeId);
-            const items: Resource[] = rows.map(({ data, meta, name }) => {
-                const flat = meta?.metadata ?? {};
-                const root: any = {};
-
-                for (const [key, valueRaw] of Object.entries(flat)) {
-                    if (typeof valueRaw !== 'string') {
-                        continue;
-                    }
-
-                    const valueString = valueRaw.trim();
-                    let value: any = 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 as string).length === 0) as Array<[string, string | undefined]>;
-
-                if (missing.length) {
-                    const keys = missing.map(([key]) => key).join(', ');
-                    throw new Error(`Missing required metadata keys [${keys}] for resource file: ${name}`);
-                }
-
+        resourceTypeHandles.map(async (resourceTypeHandle) => {
+            const pointers = await fetchTimestampedMetadataUnder(resourceTypeHandle);
+            const items: Resource[] = await Promise.all(pointers.map(async (resourcePointer) => {
+                const projection = await fetchProjection(resourceTypeHandle, resourcePointer.id);
                 return {
-                    id,
-                    resourceTypeId,
-                    creationContext: {
-                        resourceRoleId,
-                        toolStepId,
-                    },
-                    resourceShellKind,
-                    version,
-                    timestamp: timestamp as string,
-                    path: resourcePath as string,
-                    nucleus: data as any,
-                } as unknown as Resource;
-            });
+                    ...resourcePointer,
+                    projection,
+                };
+            }));
 
-            return [resourceTypeId, items] as const;
+            return [resourceTypeHandle, items] as const;
         }),
     );
 

package/src/lookups/lookups.ts

@@ -0,0 +1,25 @@
+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',
+        },
+    },
+} as const;
+
+export const MAPPINGS = {
+    ..._MAPPINGS,
+} as const;

package/src/types/types.ts

@@ -1,10 +1,9 @@
 import type {
-    StepKind,
     Resource,
-    ResourceTypeId,
-} from '@toolproof-core/schema';
-import { CONSTANTS } from '../artifacts/artifacts.js';
-import { MAPPINGS } from '../artifacts/artifacts.js';
+    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;
 
@@ -12,19 +11,17 @@ export type Collection = keyof typeof CONSTANTS.Persistence.Collections;
 
 export type SchemaLike = Record<string, unknown>;
 
-export type ResourcesByType = Record<ResourceTypeId, Resource[]>;
+export type ResourcesByType = Record<ResourceTypeHandle, Resource[]>;
 
-export type IdName = keyof typeof MAPPINGS.IdNameToIdPrefix;
+export type IdentifierName = keyof typeof MAPPINGS.IdentifierNameToPrefix;
 
-export type IdStringByIdName<K extends IdName> = `${(typeof MAPPINGS.IdNameToIdPrefix)[K]}${string}`;
+export type IdentifierStringByName<K extends IdentifierName> = `${(typeof MAPPINGS.IdentifierNameToPrefix)[K]}${string}`;
 
-export type StepIdStringByStepKind<K extends StepKind> = string & { readonly __stepKind?: K };
-
-export interface NucleusBaseSmall<T extends string = 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;
 }