@toolproof-core/lib 1.0.1 → 1.0.3

package/src/{firebase → _lib/setup}/firebaseAdminInit.ts

@@ -1,38 +1,38 @@
-import { getApp, getApps, initializeApp, applicationDefault, cert } from 'firebase-admin/app';
-import { getFirestore } from 'firebase-admin/firestore';
-import { getStorage } from 'firebase-admin/storage';
-import { existsSync, readFileSync } from 'fs';
-import path from 'path';
-
-// Resolve credentials: prefer GOOGLE_APPLICATION_CREDENTIALS, fallback to local gcp-key.json, else ADC
-function resolveCredential() {
-    const jsonString = process.env.GOOGLE_APPLICATION_CREDENTIALS_JSON;
-    const envPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
-    const localKeyPath = path.join(process.cwd(), 'gcp-key.json');
-    try {
-        if (jsonString) {
-            const json = JSON.parse(jsonString);
-            return cert(json);
-        }
-        if (envPath && existsSync(envPath)) {
-            const json = JSON.parse(readFileSync(envPath, 'utf8'));
-            return cert(json);
-        }
-        if (existsSync(localKeyPath)) {
-            const json = JSON.parse(readFileSync(localKeyPath, 'utf8'));
-            return cert(json);
-        }
-    } catch {
-        // fall through to ADC
-    }
-    return applicationDefault();
-}
-
-const app = getApps().length ? getApp() : initializeApp({
-    credential: resolveCredential(),
-    projectId: "toolproof-563fe",
-});
-const dbAdmin = getFirestore(app);
-const storageAdmin = getStorage(app);
-
-export { dbAdmin, storageAdmin };
+import { getApp, getApps, initializeApp, applicationDefault, cert } from 'firebase-admin/app';
+import { getFirestore } from 'firebase-admin/firestore';
+import { getStorage } from 'firebase-admin/storage';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+
+// Resolve credentials: prefer GOOGLE_APPLICATION_CREDENTIALS, fallback to local gcp-key.json, else ADC
+function resolveCredential() {
+    const jsonString = process.env.GOOGLE_APPLICATION_CREDENTIALS_JSON;
+    const envPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
+    const localKeyPath = path.join(process.cwd(), 'gcp-key.json');
+    try {
+        if (jsonString) {
+            const json = JSON.parse(jsonString);
+            return cert(json);
+        }
+        if (envPath && existsSync(envPath)) {
+            const json = JSON.parse(readFileSync(envPath, 'utf8'));
+            return cert(json);
+        }
+        if (existsSync(localKeyPath)) {
+            const json = JSON.parse(readFileSync(localKeyPath, 'utf8'));
+            return cert(json);
+        }
+    } catch {
+        // fall through to ADC
+    }
+    return applicationDefault();
+}
+
+const app = getApps().length ? getApp() : initializeApp({
+    credential: resolveCredential(),
+    projectId: "toolproof-563fe",
+});
+const dbAdmin = getFirestore(app);
+const storageAdmin = getStorage(app);
+
+export { dbAdmin, storageAdmin };

package/{dist/constants/constants.js → src/artifacts/artifacts.ts}

@@ -1,23 +1,24 @@
-import { CONSTANTS as CONSTANTS_ } from "@toolproof-core/schema";
+import { CONSTANTS as _CONSTANTS, MAPPINGS as _MAPPINGS } from "@toolproof-core/schema";
+
 export const CONSTANTS = {
-    ...CONSTANTS_,
-    PERSISTENCE: {
-        BUCKETS: {
+    ..._CONSTANTS,
+    Persistence: {
+        Buckets: {
             tp_resources: 'tp-resources',
             tp_strategies: 'tp-strategies',
         },
-        COLLECTIONS: {
+        Collections: {
             resources: 'resources',
             members: 'members',
         },
     },
-    ENGINE: {
-        GRAPHS: {
+    Engine: {
+        Graphs: {
             GraphRunStrategy: 'GraphRunStrategy',
             GraphBuildStrategy: 'GraphBuildStrategy',
         },
     },
-    COSMOS: {
+    Cosmos: {
         TYPE_Boolean: 'TYPE-Boolean',
         TYPE_Natural: 'TYPE-Natural',
         TYPE_ResourceType: 'TYPE-ResourceType',
@@ -32,8 +33,9 @@ export const CONSTANTS = {
         ROLE_LessThanTarget: 'ROLE-LessThanTarget',
         ROLE_LessThanDecision: 'ROLE-LessThanDecision',
         JOB_LessThan: 'JOB-LessThan',
-        BOOLEAN_false: 'RESOURCE-qadnfFGjZsjpqLI0Du1d',
-        BOOLEAN_true: 'RESOURCE-iZX1cxZ9ImJRzty9Ob4G',
     }
-};
-//# sourceMappingURL=constants.js.map
+} as const;
+
+export const MAPPINGS = {
+    ..._MAPPINGS,
+} as const;

package/src/firebase/firebaseAdminHelpers.ts

@@ -1,189 +1,157 @@
-import type {
-    BranchStepIdentityJson,
-    ForStepIdentityJson,
-    GoalIdentityJson,
-    JobIdentityJson,
-    JobStepIdentityJson,
-    ResourceJson,
-    ResourceIdentityJson,
-    ResourceRoleIdentityJson,
-    ResourceTypeIdentityJson,
-    RunnableStrategyIdentityJson,
-    StrategyRunIdentityJson,
-    StrategyThreadIdentityJson,
-    WhileStepIdentityJson,
-} from '@toolproof-core/schema';
-import type { ResourceMap, IdentityPrefix } from '../types/types.js';
-import { CONSTANTS } from '../constants/constants.js';
-import { dbAdmin, storageAdmin } from "./firebaseAdminInit.js";
-
-export type StepKind = keyof typeof CONSTANTS.ENUMS.StepKind;
-
-const STEP_KIND_TO_IDENTITY_PREFIX_KEY = {
-    job: 'JobStepIdentity',
-    branch: 'BranchStepIdentity',
-    while: 'WhileStepIdentity',
-    for: 'ForStepIdentity',
-} as const;
-
-type StepIdentityPrefixKey = (typeof STEP_KIND_TO_IDENTITY_PREFIX_KEY)[StepKind];
-
-type IdentityJsonByPrefixKey = {
-    ResourceTypeIdentity: ResourceTypeIdentityJson;
-    ResourceRoleIdentity: ResourceRoleIdentityJson;
-    ResourceIdentity: ResourceIdentityJson;
-    JobIdentity: JobIdentityJson;
-    JobStepIdentity: JobStepIdentityJson;
-    BranchStepIdentity: BranchStepIdentityJson;
-    WhileStepIdentity: WhileStepIdentityJson;
-    ForStepIdentity: ForStepIdentityJson;
-    StrategyThreadIdentity: StrategyThreadIdentityJson;
-    RunnableStrategyIdentity: RunnableStrategyIdentityJson;
-    StrategyRunIdentity: StrategyRunIdentityJson;
-    GoalIdentity: GoalIdentityJson;
-};
-
-export type NewIdentity<T extends IdentityPrefix = IdentityPrefix> =
-    T extends keyof IdentityJsonByPrefixKey
-    ? IdentityJsonByPrefixKey[T]
-    : `${(typeof CONSTANTS.IDENTIFIABLES.PREFIXES)[T]}${string}`;
-
-export function getNewIdentity<T extends IdentityPrefix>(identifiable: T): NewIdentity<T> {
-    const prefix = CONSTANTS.IDENTIFIABLES.PREFIXES[identifiable];
-    const docRef = dbAdmin
-        .collection(CONSTANTS.PERSISTENCE.COLLECTIONS.resources)
-        .doc(identifiable)
-        .collection(CONSTANTS.PERSISTENCE.COLLECTIONS.members)
-        .doc();
-    return (prefix + docRef.id) as NewIdentity<T>;
-}
-
-export function getNewStepIdentityPrefix<K extends StepKind>(kind: K): (typeof CONSTANTS.IDENTIFIABLES.PREFIXES)[StepIdentityPrefixKey] {
-    const key = STEP_KIND_TO_IDENTITY_PREFIX_KEY[kind];
-    return CONSTANTS.IDENTIFIABLES.PREFIXES[key];
-}
-
-type StepIdentityForKind<K extends StepKind> = IdentityJsonByPrefixKey[(typeof STEP_KIND_TO_IDENTITY_PREFIX_KEY)[K]];
-
-export async function getNewStepIdentity<K extends StepKind>(kind: K): Promise<StepIdentityForKind<K>> {
-    const key = STEP_KIND_TO_IDENTITY_PREFIX_KEY[kind];
-    return getNewIdentity(key) as StepIdentityForKind<K>;
-}
-
-export async function listResources(
-    resourceTypeHandles: ResourceTypeIdentityJson[]
-): Promise<ResourceMap> {
-    const bucket_resources = storageAdmin.bucket(CONSTANTS.PERSISTENCE.BUCKETS.tp_resources);
-    const bucket_strategies = storageAdmin.bucket(CONSTANTS.PERSISTENCE.BUCKETS.tp_strategies);
-
-    async function fetchFilesUnder(resourceTypeHandle: ResourceTypeIdentityJson): Promise<Array<{ data: unknown; meta: any; name: string }>> {
-        const bucket = resourceTypeHandle === CONSTANTS.COSMOS.TYPE_RunnableStrategy
-            ? bucket_strategies
-            : bucket_resources;
-        const prefix = `${resourceTypeHandle}/`;
-        const [found] = await bucket.getFiles({ prefix });
-        const files = found.filter(f => {
-            const name = f.name || '';
-            if (!name || name.endsWith('/')) return false;
-            return true;
-        });
-        if (!files.length) return [];
-        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 entries = await Promise.all(
-        resourceTypeHandles.map(async (resourceTypeHandle) => {
-            const rows = await fetchFilesUnder(resourceTypeHandle);
-            const items: ResourceJson[] = rows.map(({ data, meta, name }) => {
-                const flat = meta?.metadata ?? {};
-                // Reconstruct nested object from flattened keys (dot and array index notation)
-                const root: any = {};
-                for (const [k, vRaw] of Object.entries(flat)) {
-                    if (typeof vRaw !== 'string') continue; // GCS should store only strings
-                    const vStr = vRaw.trim();
-                    // Attempt JSON parse for non-simple primitives
-                    let value: any = vStr;
-                    if ((vStr.startsWith('{') && vStr.endsWith('}')) || (vStr.startsWith('[') && vStr.endsWith(']'))) {
-                        try { value = JSON.parse(vStr); } catch { value = vStr; }
-                    }
-                    // Split by '.' while preserving array indices
-                    const segments = k.split('.');
-                    let cursor = root;
-                    for (const [i, seg] of segments.entries()) {
-                        const arrIdxMatch = seg.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]) cursor[base] = [];
-                            if (!Array.isArray(cursor[base])) cursor[base] = [];
-                            while (cursor[base].length <= idx) cursor[base].push(undefined);
-                            if (i === segments.length - 1) {
-                                cursor[base][idx] = value;
-                            } else {
-                                if (!cursor[base][idx]) cursor[base][idx] = {};
-                                cursor = cursor[base][idx];
-                            }
-                        } else {
-                            if (i === segments.length - 1) {
-                                cursor[seg] = value;
-                            } else {
-                                if (!cursor[seg] || typeof cursor[seg] !== 'object') cursor[seg] = {};
-                                cursor = cursor[seg];
-                            }
-                        }
-                    }
-                }
-                const identity = root.identity;
-                // const resourceTypeHandle = root.resourceTypeHandle; // we already have this
-                const resourceRoleHandle = root.creationContext.resourceRoleHandle;
-                const jobStepHandle = root.creationContext.jobStepHandle;
-                const stepKind = root.stepKind;
-                const path = root.path;
-                const timestamp = root.timestamp;
-
-                const missing = [
-                    ['identity', identity],
-                    ['resourceRoleHandle', resourceRoleHandle],
-                    ['jobStepHandle', jobStepHandle],
-                    ['stepKind', stepKind],
-                    ['timestamp', timestamp],
-                    ['path', path],
-                ].filter(([_, v]) => typeof v !== 'string' || (v as string).length === 0) as Array<[string, string | undefined]>;
-
-                if (missing.length) {
-                    const keys = missing.map(([k]) => k).join(', ');
-                    throw new Error(`Missing required metadata keys [${keys}] for resource file: ${name}`);
-                }
-
-                return {
-                    identity,
-                    resourceTypeHandle,
-                    creationContext: {
-                        resourceRoleHandle,
-                        jobStepHandle,
-                    },
-                    stepKind: stepKind as string,
-                    path: path as string,
-                    timestamp: timestamp as string,
-                    nucleus: data as any,
-                } as unknown as ResourceJson;
-            });
-            return [resourceTypeHandle, items] as const;
-        })
-    );
-    return Object.fromEntries(entries) as ResourceMap;
-}
-
-
+import type {
+    ResourceJson,
+    ResourceTypeIdentityJson,
+    StepKindJson,
+} from '@toolproof-core/schema';
+import type { IdentityName, IdentityStringByIdentityName, StepIdentityStringByStepKind, ResourceMap } from '../types/types.js';
+import { CONSTANTS } from '../artifacts/artifacts.js';
+import { MAPPINGS } from '../artifacts/artifacts.js';
+import { dbAdmin, storageAdmin } from "../_lib/setup/firebaseAdminInit.js";
+
+
+function capitalizeFirst(value: string): string {
+    if (!value) return value;
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+export function getNewIdentity<K extends IdentityName>(identityName: K): IdentityStringByIdentityName<K> {
+    const prefix = MAPPINGS.IdentityNameToIdentityPrefix[identityName];
+    const docRef = dbAdmin
+        .collection(CONSTANTS.Persistence.Collections.resources)
+        .doc(identityName)
+        .collection(CONSTANTS.Persistence.Collections.members)
+        .doc();
+    return (prefix + docRef.id) as IdentityStringByIdentityName<K>;
+}
+
+export function getNewStepIdentity<K extends StepKindJson>(stepKind: K): StepIdentityStringByStepKind<K> {
+    const identityName = `${capitalizeFirst(stepKind)}StepIdentity` as IdentityName;
+    if (!(identityName in MAPPINGS.IdentityNameToIdentityPrefix)) {
+        throw new Error(`No IdentityNameToIdentityPrefix entry for derived step identity name: ${identityName}`);
+    }
+    return getNewIdentity(identityName) as StepIdentityStringByStepKind<K>;
+}
+
+export async function listResources(
+    resourceTypeHandles: ResourceTypeIdentityJson[]
+): Promise<ResourceMap> {
+    const bucket_resources = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_resources);
+    const bucket_strategies = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_strategies);
+
+    async function fetchFilesUnder(resourceTypeHandle: ResourceTypeIdentityJson): Promise<Array<{ data: unknown; meta: any; name: string }>> {
+        const bucket = resourceTypeHandle === CONSTANTS.Cosmos.TYPE_RunnableStrategy
+            ? bucket_strategies
+            : bucket_resources;
+        const prefix = `${resourceTypeHandle}/`;
+        const [found] = await bucket.getFiles({ prefix });
+        const files = found.filter(f => {
+            const name = f.name || '';
+            if (!name || name.endsWith('/')) return false;
+            return true;
+        });
+        if (!files.length) return [];
+        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 entries = await Promise.all(
+        resourceTypeHandles.map(async (resourceTypeHandle) => {
+            const rows = await fetchFilesUnder(resourceTypeHandle);
+            const items: ResourceJson[] = rows.map(({ data, meta, name }) => {
+                const flat = meta?.metadata ?? {};
+                // Reconstruct nested object from flattened keys (dot and array index notation)
+                const root: any = {};
+                for (const [k, vRaw] of Object.entries(flat)) {
+                    if (typeof vRaw !== 'string') continue; // GCS should store only strings
+                    const vStr = vRaw.trim();
+                    // Attempt JSON parse for non-simple primitives
+                    let value: any = vStr;
+                    if ((vStr.startsWith('{') && vStr.endsWith('}')) || (vStr.startsWith('[') && vStr.endsWith(']'))) {
+                        try { value = JSON.parse(vStr); } catch { value = vStr; }
+                    }
+                    // Split by '.' while preserving array indices
+                    const segments = k.split('.');
+                    let cursor = root;
+                    for (const [i, seg] of segments.entries()) {
+                        const arrIdxMatch = seg.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]) cursor[base] = [];
+                            if (!Array.isArray(cursor[base])) cursor[base] = [];
+                            while (cursor[base].length <= idx) cursor[base].push(undefined);
+                            if (i === segments.length - 1) {
+                                cursor[base][idx] = value;
+                            } else {
+                                if (!cursor[base][idx]) cursor[base][idx] = {};
+                                cursor = cursor[base][idx];
+                            }
+                        } else {
+                            if (i === segments.length - 1) {
+                                cursor[seg] = value;
+                            } else {
+                                if (!cursor[seg] || typeof cursor[seg] !== 'object') cursor[seg] = {};
+                                cursor = cursor[seg];
+                            }
+                        }
+                    }
+                }
+                const identity = root.identity;
+                // const resourceTypeHandle = root.resourceTypeHandle; // we already have this
+                const resourceRoleHandle = root.creationContext.resourceRoleHandle;
+                const jobStepHandle = root.creationContext.jobStepHandle;
+                const resourceShellKind = root.resourceShellKind;
+                const versionRaw = root.version;
+                const version = typeof versionRaw === 'number'
+                    ? versionRaw
+                    : parseInt(String(versionRaw ?? ''), 10);
+                const path = root.path;
+                const timestamp = root.timestamp;
+
+                const missing = [
+                    ['identity', identity],
+                    ['resourceRoleHandle', resourceRoleHandle],
+                    ['jobStepHandle', jobStepHandle],
+                    ['resourceShellKind', resourceShellKind],
+                    ['version', Number.isFinite(version) ? String(version) : ''],
+                    ['timestamp', timestamp],
+                    ['path', path],
+                ].filter(([_, v]) => typeof v !== 'string' || (v as string).length === 0) as Array<[string, string | undefined]>;
+
+                if (missing.length) {
+                    const keys = missing.map(([k]) => k).join(', ');
+                    throw new Error(`Missing required metadata keys [${keys}] for resource file: ${name}`);
+                }
+
+                return {
+                    identity,
+                    resourceTypeHandle,
+                    creationContext: {
+                        resourceRoleHandle,
+                        jobStepHandle,
+                    },
+                    resourceShellKind,
+                    version,
+                    timestamp: timestamp as string,
+                    path: path as string,
+                    nucleus: data as any,
+                } as unknown as ResourceJson;
+            });
+            return [resourceTypeHandle, items] as const;
+        })
+    );
+    return Object.fromEntries(entries) as ResourceMap;
+}
+
+

package/src/types/types.ts

@@ -1,17 +1,25 @@
-import type {
-	ResourceJson,
-	ResourceRoleIdentityJson,
-	ResourceRoleValueJson,
-	ResourceTypeIdentityJson,
-} from '@toolproof-core/schema';
-import { CONSTANTS } from '../constants/constants.js';
-
-export type BucketConst = typeof CONSTANTS.PERSISTENCE.BUCKETS.tp_resources;
-
-export type CollectionConst = keyof typeof CONSTANTS.PERSISTENCE.COLLECTIONS;
-
-export type IdentityPrefix = keyof typeof CONSTANTS.IDENTIFIABLES.PREFIXES;
-
-export type Role = { identity: ResourceRoleIdentityJson } & ResourceRoleValueJson;
-
-export type ResourceMap = Record<ResourceTypeIdentityJson, ResourceJson[]>;
+import type {
+	StepKindJson,
+	ResourceJson,
+	ResourceRoleIdentityJson,
+	ResourceRoleValueJson,
+	ResourceTypeIdentityJson,
+} 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;
+
+export type Collection = keyof typeof CONSTANTS.Persistence.Collections;
+
+export type SchemaLike = Record<string, unknown>;
+
+export type Role = { identity: ResourceRoleIdentityJson } & ResourceRoleValueJson;
+
+export type ResourceMap = Record<ResourceTypeIdentityJson, ResourceJson[]>;
+
+export type IdentityName = keyof typeof MAPPINGS.IdentityNameToIdentityPrefix;
+
+export type IdentityStringByIdentityName<K extends IdentityName> = `${(typeof MAPPINGS.IdentityNameToIdentityPrefix)[K]}${string}`;
+
+export type StepIdentityStringByStepKind<K extends StepKindJson> = `${(typeof MAPPINGS.StepKindToStepIdentityPrefix)[K]}${string}`;

package/src/utils/creation.ts

@@ -0,0 +1,27 @@
+import type { ResourceIdentityJson, ResourceTypeIdentityJson, ResourceJson, ResourceOutputPotentialJson } from '@toolproof-core/schema';
+
+
+export function generatePath(resourceTypeHandle: ResourceTypeIdentityJson, identity: ResourceIdentityJson): string {
+    return `${resourceTypeHandle}/${identity}.json`;
+}
+
+export function fromOutputPotentialToMaterialized(
+    outputPotential: ResourceOutputPotentialJson,
+    nucleus: unknown,
+    timestamp?: string
+): ResourceJson {
+    const { identity, resourceTypeHandle, creationContext } = outputPotential;
+
+    const path = generatePath(resourceTypeHandle, identity);
+
+    return {
+        identity,
+        resourceTypeHandle,
+        creationContext,
+        resourceShellKind: 'materialized',
+        version: 1,
+        timestamp: timestamp ?? new Date().toISOString(), // Preserve original timestamp when copying
+        path,
+        nucleus,
+    };
+}

package/src/utils/resourceMapExtraction.ts

@@ -0,0 +1,47 @@
+import type {
+    ResourceIdentityJson,
+    ResourceTypeIdentityJson,
+    ResourceJson,
+} from '@toolproof-core/schema';
+import type { ResourceMap } from '../types/types.js';
+
+
+export function extractResourcesByType<TResource extends ResourceJson = ResourceJson>(
+    resourceMap: ResourceMap,
+    resourceTypeHandle: ResourceTypeIdentityJson
+): Record<ResourceIdentityJson, TResource> {
+    const resources = (resourceMap[resourceTypeHandle] ?? []) as TResource[];
+    const result: Record<ResourceIdentityJson, TResource> = {} as Record<ResourceIdentityJson, TResource>;
+
+    for (const resource of resources) {
+        result[resource.identity] = resource;
+    }
+
+    return result;
+}
+
+/**
+ 
+ */
+export function extractNucleusMap<
+    TKey extends string = string,
+    TNucleus extends { identity: string | number | boolean } = { identity: string | number | boolean },
+    TResource extends ResourceJson = ResourceJson
+>(
+    resourceMap: ResourceMap,
+    resourceTypeHandle: ResourceTypeIdentityJson,
+): Map<TKey, TNucleus> {
+    const resources = extractResourcesByType<TResource>(resourceMap, resourceTypeHandle);
+    const out = new Map<TKey, TNucleus>();
+
+    for (const resource of Object.values(resources)) {
+        const data = (resource as any).nucleus as unknown;
+
+        const value = data as TNucleus;
+        const key = String(value.identity) as TKey;
+
+        out.set(key, value);
+    }
+
+    return out;
+}

package/tsconfig.json

@@ -1,15 +1,15 @@
-{
-    "extends": "../../tsconfig.base.json",
-    "compilerOptions": {
-        "rootDir": "./src",
-        "outDir": "./dist",
-        "types": ["node"]
-    },
-    "include": [
-        "src"
-    ],
-    "exclude": [
-        "dist",
-        "node_modules"
-    ]
+{
+    "extends": "../../tsconfig.base.json",
+    "compilerOptions": {
+        "rootDir": "./src",
+        "outDir": "./dist",
+        "types": ["node"]
+    },
+    "include": [
+        "src"
+    ],
+    "exclude": [
+        "dist",
+        "node_modules"
+    ]
 }

package/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/index.ts","./src/constants/constants.ts","./src/firebase/firebaseadminhelpers.ts","./src/firebase/firebaseadmininit.ts","./src/types/types.ts"],"version":"5.9.3"}
+{"root":["./src/_lib/setup/firebaseAdminInit.ts","./src/artifacts/artifacts.ts","./src/firebase/firebaseAdminHelpers.ts","./src/types/types.ts","./src/utils/creation.ts","./src/utils/resourceMapExtraction.ts"],"version":"5.9.3"}