@toolproof-core/lib 1.0.31 → 1.0.32

package/src/integrations/firebase/createStep.ts

@@ -1,9 +1,9 @@
 import type {
-    BranchStepJson,
-    ForStepJson,
-    ToolJson,
-    ToolStepJson,
-    WhileStepJson,
+    BranchStep,
+    ForStep,
+    Tool,
+    ToolStep,
+    WhileStep,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../../artifacts/artifacts.js';
 import {
@@ -15,15 +15,15 @@ import {
 } from '../../utils/creation/stepCreation.js';
 import { getNewStepId } from './firebaseAdminHelpers.js';
 
-export function createToolStepFromTool(tool: ToolJson): ToolStepJson {
+export function createToolStepFromTool(tool: Tool): ToolStep {
     return buildToolStepFromTool(tool, getNewStepId(CONSTANTS.Enums.StepKind.tool));
 }
 
 export function createLoopStepFromToolPair(
-    whatTool: ToolJson,
-    whenTool: ToolJson,
+    whatTool: Tool,
+    whenTool: Tool,
     stepKind: typeof CONSTANTS.Enums.StepKind.for | typeof CONSTANTS.Enums.StepKind.while,
-): ForStepJson | WhileStepJson {
+): ForStep | WhileStep {
     if (stepKind === CONSTANTS.Enums.StepKind.for) {
         return buildLoopStepFromToolPair(whatTool, whenTool, {
             stepKind,
@@ -42,8 +42,8 @@ export function createLoopStepFromToolPair(
 }
 
 export function createBranchStepFromToolPairs(
-    cases: Array<{ whatTool: ToolJson; whenTool: ToolJson }>,
-): BranchStepJson {
+    cases: Array<{ whatTool: Tool; whenTool: Tool }>,
+): BranchStep {
     return buildBranchStepFromToolPairs(
         cases,
         getNewStepId(CONSTANTS.Enums.StepKind.branch),
@@ -54,7 +54,7 @@ export function createBranchStepFromToolPairs(
     );
 }
 
-export function cloneForStep(forStep: ForStepJson): ForStepJson {
+export function cloneForStep(forStep: ForStep): ForStep {
     return cloneForStepWithIdentities(forStep, {
         stepId: getNewStepId(CONSTANTS.Enums.StepKind.for),
         whatId: getNewStepId(CONSTANTS.Enums.StepKind.tool),
@@ -62,7 +62,7 @@ export function cloneForStep(forStep: ForStepJson): ForStepJson {
     });
 }
 
-export function cloneWhileStep(whileStep: WhileStepJson): WhileStepJson {
+export function cloneWhileStep(whileStep: WhileStep): WhileStep {
     return cloneWhileStepWithIdentities(whileStep, {
         stepId: getNewStepId(CONSTANTS.Enums.StepKind.while),
         whatId: getNewStepId(CONSTANTS.Enums.StepKind.tool),

package/src/integrations/firebase/firebaseAdminHelpers.ts

@@ -1,7 +1,7 @@
 import type {
-    ResourceJson,
-    ResourceTypeIdJson,
-    StepKindJson,
+    Resource,
+    ResourceTypeId,
+    StepKind,
 } from '@toolproof-core/schema';
 import type {
     IdName,
@@ -31,7 +31,7 @@ export function getNewId<K extends IdName>(idName: K): IdStringByIdName<K> {
     return (prefix + docRef.id) as IdStringByIdName<K>;
 }
 
-export function getNewStepId<K extends StepKindJson>(stepKind: K): StepIdStringByStepKind<K> {
+export function getNewStepId<K extends StepKind>(stepKind: K): StepIdStringByStepKind<K> {
     const idName = `${capitalizeFirst(stepKind)}StepId` as IdName;
 
     if (!(idName in MAPPINGS.IdNameToIdPrefix)) {
@@ -42,13 +42,13 @@ export function getNewStepId<K extends StepKindJson>(stepKind: K): StepIdStringB
 }
 
 export async function listResources(
-    resourceTypeIds: ResourceTypeIdJson[],
+    resourceTypeIds: ResourceTypeId[],
 ): Promise<ResourcesByType> {
     const bucketResources = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_resources);
     const bucketStrategies = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_strategies);
 
     async function fetchFilesUnder(
-        resourceTypeId: ResourceTypeIdJson,
+        resourceTypeId: ResourceTypeId,
     ): Promise<Array<{ data: unknown; meta: any; name: string }>> {
         const bucket = resourceTypeId === CONSTANTS.Cosmos.TYPE_RunnableStrategy
             ? bucketStrategies
@@ -81,7 +81,7 @@ export async function listResources(
     const entries = await Promise.all(
         resourceTypeIds.map(async (resourceTypeId) => {
             const rows = await fetchFilesUnder(resourceTypeId);
-            const items: ResourceJson[] = rows.map(({ data, meta, name }) => {
+            const items: Resource[] = rows.map(({ data, meta, name }) => {
                 const flat = meta?.metadata ?? {};
                 const root: any = {};
 
@@ -184,7 +184,7 @@ export async function listResources(
                     timestamp: timestamp as string,
                     path: resourcePath as string,
                     nucleus: data as any,
-                } as unknown as ResourceJson;
+                } as unknown as Resource;
             });
 
             return [resourceTypeId, items] as const;

package/src/types/types.ts

@@ -1,7 +1,7 @@
 import type {
-    StepKindJson,
-    ResourceJson,
-    ResourceTypeIdJson,
+    StepKind,
+    Resource,
+    ResourceTypeId,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../artifacts/artifacts.js';
 import { MAPPINGS } from '../artifacts/artifacts.js';
@@ -12,13 +12,13 @@ export type Collection = keyof typeof CONSTANTS.Persistence.Collections;
 
 export type SchemaLike = Record<string, unknown>;
 
-export type ResourcesByType = Record<ResourceTypeIdJson, ResourceJson[]>;
+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 StepKindJson> = `${(typeof MAPPINGS.StepKindToStepIdPrefix)[K]}${string}`;
+export type StepIdStringByStepKind<K extends StepKind> = `${(typeof MAPPINGS.StepKindToStepIdPrefix)[K]}${string}`;
 
 export interface NucleusBaseSmall<T extends string = string> {
     id: T;

package/src/utils/bindInputRoleToResource.ts

@@ -1,21 +1,21 @@
 import type {
-    CreationContextJson,
-    ExternalInputPotentialShellJson,
-    InternalInputPotentialShellJson,
-    OutputPotentialShellJson,
-    ResourceJson,
-    ResourcePotentialJson,
-    StrategyStateJson,
+    CreationContext,
+    ExternalInputPotentialShell,
+    InternalInputPotentialShell,
+    OutputPotentialShell,
+    Resource,
+    ResourcePotential,
+    StrategyState,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../artifacts/artifacts.js';
 import { resolveResourceChain } from './resolveResourceChain.js';
 
 
 export function bindInputResInStrategyState(
-    strategyState: StrategyStateJson,
-    target: CreationContextJson,
-    resource: ResourceJson
-): StrategyStateJson {
+    strategyState: StrategyState,
+    target: CreationContext,
+    resource: Resource
+): StrategyState {
     const bucket = strategyState[target.toolStepId] ?? {};
     return {
         ...strategyState,
@@ -27,13 +27,13 @@ export function bindInputResInStrategyState(
 }
 
 export function bindInputRefInStrategyState(
-    strategyState: StrategyStateJson,
-    target: CreationContextJson,
-    source: CreationContextJson
-): StrategyStateJson {
+    strategyState: StrategyState,
+    target: CreationContext,
+    source: CreationContext
+): StrategyState {
     const sourceEntry = strategyState?.[source.toolStepId]?.[source.resourceRoleId] as (
-        | ResourceJson
-        | ResourcePotentialJson
+        | Resource
+        | ResourcePotential
         | undefined
     );
     if (!sourceEntry) {
@@ -55,7 +55,7 @@ export function bindInputRefInStrategyState(
 
     if (result.status === CONSTANTS.Enums.ResourceShellKind.externalInputPotential) {
         const externalInput = result.entry;
-        const reusedExternalInput: ExternalInputPotentialShellJson = {
+        const reusedExternalInput: ExternalInputPotentialShell = {
             id: externalInput.id,
             resourceTypeId: externalInput.resourceTypeId,
             resourceShellKind: CONSTANTS.Enums.ResourceShellKind.externalInputPotential,
@@ -71,7 +71,7 @@ export function bindInputRefInStrategyState(
     }
 
     if (result.status === CONSTANTS.Enums.ResourceShellKind.outputPotential) {
-        const potentialInput: InternalInputPotentialShellJson = {
+        const potentialInput: InternalInputPotentialShell = {
             id: sourceEntry.id,
             resourceTypeId: sourceEntry.resourceTypeId,
             creationContext: {
@@ -94,9 +94,9 @@ export function bindInputRefInStrategyState(
 }
 
 export function clearInputBindingInStrategyState(
-    strategyState: StrategyStateJson,
-    target: CreationContextJson
-): StrategyStateJson {
+    strategyState: StrategyState,
+    target: CreationContext
+): StrategyState {
     const bucket = strategyState?.[target.toolStepId];
     if (!bucket?.[target.resourceRoleId]) return strategyState;
 

package/src/utils/creation/resourceCreation.ts

@@ -1,23 +1,23 @@
 import type {
-    CreationContextJson,
-    ExternalInputPotentialShellJson,
-    InternalInputPotentialShellJson,
-    OutputPotentialShellJson,
-    ResourceIdJson,
-    ResourceJson,
-    ResourceTypeIdJson,
+    CreationContext,
+    ExternalInputPotentialShell,
+    InternalInputPotentialShell,
+    OutputPotentialShell,
+    ResourceId,
+    Resource,
+    ResourceTypeId,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../../artifacts/artifacts.js';
 
-export function generatePath(resourceTypeId: ResourceTypeIdJson, id: ResourceIdJson): string {
+export function generatePath(resourceTypeId: ResourceTypeId, id: ResourceId): string {
     return `${resourceTypeId}/${id}.json`;
 }
 
 export function createMaterializedFromOutputPotential(
-    outputPotential: OutputPotentialShellJson,
+    outputPotential: OutputPotentialShell,
     nucleus: unknown,
     timestamp?: string,
-): ResourceJson {
+): Resource {
     const { id, resourceTypeId, creationContext } = outputPotential;
     const path = generatePath(resourceTypeId, id);
 
@@ -34,10 +34,10 @@ export function createMaterializedFromOutputPotential(
 }
 
 export function createMaterializedFromInputPotential(
-    inputPotential: InternalInputPotentialShellJson,
+    inputPotential: InternalInputPotentialShell,
     nucleus: unknown,
     timestamp?: string,
-): ResourceJson {
+): Resource {
     const { id, resourceTypeId, creationContext } = inputPotential;
     const path = generatePath(resourceTypeId, id);
 
@@ -54,10 +54,10 @@ export function createMaterializedFromInputPotential(
 }
 
 export function createMaterializedFromPotential(
-    potential: InternalInputPotentialShellJson | OutputPotentialShellJson,
+    potential: InternalInputPotentialShell | OutputPotentialShell,
     nucleus: unknown,
     timestamp?: string,
-): ResourceJson {
+): Resource {
     if (potential.resourceShellKind === CONSTANTS.Enums.ResourceShellKind.internalInputPotential) {
         return createMaterializedFromInputPotential(potential, nucleus, timestamp);
     }
@@ -66,9 +66,9 @@ export function createMaterializedFromPotential(
 }
 
 export function createExternalInputPotential(
-    id: ResourceIdJson,
-    resourceTypeId: ResourceTypeIdJson,
-): ExternalInputPotentialShellJson {
+    id: ResourceId,
+    resourceTypeId: ResourceTypeId,
+): ExternalInputPotentialShell {
     return {
         id,
         resourceTypeId,
@@ -77,10 +77,10 @@ export function createExternalInputPotential(
 }
 
 export function createInputPotential(
-    id: ResourceIdJson,
-    resourceTypeId: ResourceTypeIdJson,
-    creationContext: CreationContextJson,
-): InternalInputPotentialShellJson {
+    id: ResourceId,
+    resourceTypeId: ResourceTypeId,
+    creationContext: CreationContext,
+): InternalInputPotentialShell {
     return {
         id,
         resourceTypeId,
@@ -90,10 +90,10 @@ export function createInputPotential(
 }
 
 export function createOutputPotential(
-    id: ResourceIdJson,
-    resourceTypeId: ResourceTypeIdJson,
-    creationContext: CreationContextJson,
-): OutputPotentialShellJson {
+    id: ResourceId,
+    resourceTypeId: ResourceTypeId,
+    creationContext: CreationContext,
+): OutputPotentialShell {
     return {
         id,
         resourceTypeId,

package/src/utils/creation/runnableStrategyCreation.ts

@@ -1,28 +1,28 @@
 import type {
-    RawStrategyJson,
-    RunnableStrategyIdJson,
-    RunnableStrategyJson,
-    StepJson,
-    StepArrayByStrategyThreadJson,
-    StrategyThreadIdJson,
+    RawStrategy,
+    RunnableStrategyId,
+    RunnableStrategy,
+    Step,
+    StepArrayByStrategyThread,
+    StrategyThreadId,
 } from '@toolproof-core/schema';
 import { getIndependentThreads } from '../parallelizeSteps.js';
 
-export function getRunnableStrategyThreadGroups(rawStrategy: RawStrategyJson): StepJson[][] {
+export function getRunnableStrategyThreadGroups(rawStrategy: RawStrategy): Step[][] {
     return getIndependentThreads(rawStrategy.steps, rawStrategy.strategyState);
 }
 
 export function buildRunnableStrategy(
-    rawStrategy: RawStrategyJson,
-    runnableStrategyId: RunnableStrategyIdJson,
-    threadStepGroups: StepJson[][],
-    threadIdentities: StrategyThreadIdJson[],
-): RunnableStrategyJson {
+    rawStrategy: RawStrategy,
+    runnableStrategyId: RunnableStrategyId,
+    threadStepGroups: Step[][],
+    threadIdentities: StrategyThreadId[],
+): RunnableStrategy {
     if (threadStepGroups.length !== threadIdentities.length) {
         throw new Error('buildRunnableStrategy requires one thread id per thread group');
     }
 
-    const stepsByStrategyThread: StepArrayByStrategyThreadJson = {};
+    const stepsByStrategyThread: StepArrayByStrategyThread = {};
 
     for (const [index, group] of threadStepGroups.entries()) {
         const threadId = threadIdentities[index];

package/src/utils/creation/stepCreation.ts

@@ -1,35 +1,35 @@
 import type {
-    BranchStepIdJson,
-    BranchStepJson,
-    CaseJson,
-    ForStepIdJson,
-    ForStepJson,
-    ToolJson,
-    ToolStepIdJson,
-    ToolStepJson,
-    ResourceRoleIdJson,
-    WhileStepIdJson,
-    WhileStepJson,
+    BranchStepId,
+    BranchStep,
+    Case,
+    ForStepId,
+    ForStep,
+    Tool,
+    ToolStepId,
+    ToolStep,
+    ResourceRoleId,
+    WhileStepId,
+    WhileStep,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../../artifacts/artifacts.js';
 
 export type LoopStepBuildIdentities =
     | {
         stepKind: typeof CONSTANTS.Enums.StepKind.for;
-        stepId: ForStepIdJson;
-        whatId: ToolStepIdJson;
-        whenId: ToolStepIdJson;
+        stepId: ForStepId;
+        whatId: ToolStepId;
+        whenId: ToolStepId;
     }
     | {
         stepKind: typeof CONSTANTS.Enums.StepKind.while;
-        stepId: WhileStepIdJson;
-        whatId: ToolStepIdJson;
-        whenId: ToolStepIdJson;
+        stepId: WhileStepId;
+        whatId: ToolStepId;
+        whenId: ToolStepId;
     };
 
 export type BranchCaseBuildIdentities = {
-    whatId: ToolStepIdJson;
-    whenId: ToolStepIdJson;
+    whatId: ToolStepId;
+    whenId: ToolStepId;
 };
 
 function assertNonEmpty<T>(arr: T[], msg: string): asserts arr is [T, ...T[]] {
@@ -38,17 +38,17 @@ function assertNonEmpty<T>(arr: T[], msg: string): asserts arr is [T, ...T[]] {
     }
 }
 
-function getRoleBindingSpec(tool: ToolJson): ToolStepJson['roleBindingSpec'] {
+function getRoleBindingSpec(tool: Tool): ToolStep['roleBindingSpec'] {
     return {
-        inputBindings: Object.keys(tool.roleSpec.inputRoleValueById) as ResourceRoleIdJson[],
-        outputBindings: Object.keys(tool.roleSpec.outputRoleValueById) as ResourceRoleIdJson[],
+        inputBindings: Object.keys(tool.roleSpec.inputRoleValueById) as ResourceRoleId[],
+        outputBindings: Object.keys(tool.roleSpec.outputRoleValueById) as ResourceRoleId[],
     };
 }
 
 export function buildToolStepFromTool(
-    tool: ToolJson,
-    id: ToolStepIdJson,
-): ToolStepJson {
+    tool: Tool,
+    id: ToolStepId,
+): ToolStep {
     return {
         id,
         stepKind: CONSTANTS.Enums.StepKind.tool,
@@ -58,10 +58,10 @@ export function buildToolStepFromTool(
 }
 
 export function buildLoopStepFromToolPair(
-    whatTool: ToolJson,
-    whenTool: ToolJson,
+    whatTool: Tool,
+    whenTool: Tool,
     identities: LoopStepBuildIdentities,
-): ForStepJson | WhileStepJson {
+): ForStep | WhileStep {
     const what = buildToolStepFromTool(whatTool, identities.whatId);
     const when = buildToolStepFromTool(whenTool, identities.whenId);
 
@@ -81,10 +81,10 @@ export function buildLoopStepFromToolPair(
 }
 
 export function buildBranchStepFromToolPairs(
-    cases: Array<{ whatTool: ToolJson; whenTool: ToolJson }>,
-    branchId: BranchStepIdJson,
+    cases: Array<{ whatTool: Tool; whenTool: Tool }>,
+    branchId: BranchStepId,
     caseIdentities: BranchCaseBuildIdentities[],
-): BranchStepJson {
+): BranchStep {
     if (cases.length !== caseIdentities.length) {
         throw new Error('buildBranchStepFromToolPairs requires one id pair per case');
     }
@@ -98,7 +98,7 @@ export function buildBranchStepFromToolPairs(
 
         const what = buildToolStepFromTool(whatTool, identities.whatId);
         const when = buildToolStepFromTool(whenTool, identities.whenId);
-        return { what, when } satisfies CaseJson;
+        return { what, when } satisfies Case;
     });
 
     assertNonEmpty(resolved, 'buildBranchStepFromToolPairs requires at least one case');
@@ -111,13 +111,13 @@ export function buildBranchStepFromToolPairs(
 }
 
 export function cloneForStepWithIdentities(
-    forStep: ForStepJson,
+    forStep: ForStep,
     identities: {
-        stepId: ForStepIdJson;
-        whatId: ToolStepIdJson;
-        whenId: ToolStepIdJson;
+        stepId: ForStepId;
+        whatId: ToolStepId;
+        whenId: ToolStepId;
     },
-): ForStepJson {
+): ForStep {
     return {
         id: identities.stepId,
         stepKind: CONSTANTS.Enums.StepKind.for,
@@ -135,13 +135,13 @@ export function cloneForStepWithIdentities(
 }
 
 export function cloneWhileStepWithIdentities(
-    whileStep: WhileStepJson,
+    whileStep: WhileStep,
     identities: {
-        stepId: WhileStepIdJson;
-        whatId: ToolStepIdJson;
-        whenId: ToolStepIdJson;
+        stepId: WhileStepId;
+        whatId: ToolStepId;
+        whenId: ToolStepId;
     },
-): WhileStepJson {
+): WhileStep {
     return {
         id: identities.stepId,
         stepKind: CONSTANTS.Enums.StepKind.while,

package/src/utils/extractData.ts

@@ -1,33 +1,33 @@
 import type {
-    RawStrategyJson,
-    ToolIdJson,
-    ToolJson,
-    ToolStepIdJson,
-    ToolStepJson,
-    StepJson,
-    ResourceRoleIdJson,
-    ResourceRoleJson,
-    ResourceIdJson,
-    ResourceTypeIdJson,
-    ResourceJson,
+    RawStrategy,
+    ToolId,
+    Tool,
+    ToolStepId,
+    ToolStep,
+    Step,
+    ResourceRoleId,
+    ResourceRole,
+    ResourceId,
+    ResourceTypeId,
+    Resource,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../artifacts/artifacts.js';
 
 
-export function extractToolIdsFromRawStrategy(rawStrategy: RawStrategyJson): ToolIdJson[] {
+export function extractToolIdsFromRawStrategy(rawStrategy: RawStrategy): ToolId[] {
     const toolSteps = extractToolStepsFromRawStrategy(rawStrategy);
-    const ids = new Set<ToolIdJson>();
+    const ids = new Set<ToolId>();
     for (const jStep of toolSteps) {
         ids.add(jStep.toolId);
     }
     return Array.from(ids);
 }
 
-export function extractToolStepsFromRawStrategy(rawStrategy: RawStrategyJson): ToolStepJson[] {
-    const toolSteps: ToolStepJson[] = [];
-    const seen = new Set<ToolStepIdJson>();
+export function extractToolStepsFromRawStrategy(rawStrategy: RawStrategy): ToolStep[] {
+    const toolSteps: ToolStep[] = [];
+    const seen = new Set<ToolStepId>();
 
-    const addToolStep = (toolStep: ToolStepJson) => {
+    const addToolStep = (toolStep: ToolStep) => {
         if (seen.has(toolStep.id)) {
             throw new Error(`Duplicate tool step id encountered: ${toolStep.id}`);
         }
@@ -35,7 +35,7 @@ export function extractToolStepsFromRawStrategy(rawStrategy: RawStrategyJson): T
         toolSteps.push(toolStep);
     };
 
-    const visitStep = (step: StepJson) => {
+    const visitStep = (step: Step) => {
         switch (step.stepKind) {
             case CONSTANTS.Enums.StepKind.tool: {
                 addToolStep(step);
@@ -69,8 +69,8 @@ export function extractToolStepsFromRawStrategy(rawStrategy: RawStrategyJson): T
 }
 
 
-export function extractRoleMapFromRawStrategy(rawStrategy: RawStrategyJson, toolMap: Map<ToolIdJson, ToolJson>): Map<ResourceRoleIdJson, ResourceRoleJson> {
-    const roleMap = new Map<ResourceRoleIdJson, ResourceRoleJson>();
+export function extractRoleMapFromRawStrategy(rawStrategy: RawStrategy, toolMap: Map<ToolId, Tool>): Map<ResourceRoleId, ResourceRole> {
+    const roleMap = new Map<ResourceRoleId, ResourceRole>();
     const toolIds = extractToolIdsFromRawStrategy(rawStrategy);
 
     for (const toolId of toolIds) {
@@ -78,14 +78,14 @@ export function extractRoleMapFromRawStrategy(rawStrategy: RawStrategyJson, tool
         if (!tool) continue;
 
         for (const [rid, role] of Object.entries(tool.roleSpec.inputRoleValueById)) {
-            roleMap.set(rid as ResourceRoleIdJson, {
-                id: rid as ResourceRoleIdJson,
+            roleMap.set(rid as ResourceRoleId, {
+                id: rid as ResourceRoleId,
                 ...role,
             });
         }
         for (const [rid, role] of Object.entries(tool.roleSpec.outputRoleValueById)) {
-            roleMap.set(rid as ResourceRoleIdJson, {
-                id: rid as ResourceRoleIdJson,
+            roleMap.set(rid as ResourceRoleId, {
+                id: rid as ResourceRoleId,
                 ...role,
             });
         }
@@ -94,7 +94,7 @@ export function extractRoleMapFromRawStrategy(rawStrategy: RawStrategyJson, tool
     return roleMap;
 }
 
-export function extractSingleNonErrorOutputTypeId(tool: ToolJson): ResourceTypeIdJson | null {
+export function extractSingleNonErrorOutputTypeId(tool: Tool): ResourceTypeId | null {
     const errorRoleId = CONSTANTS.Cosmos.ROLE_ErrorOutput;
     const outputEntries = Object.entries(tool.roleSpec.outputRoleValueById).filter(([roleId]) => roleId !== errorRoleId);
     if (!outputEntries || !outputEntries[0] || outputEntries.length !== 1) {
@@ -106,12 +106,12 @@ export function extractSingleNonErrorOutputTypeId(tool: ToolJson): ResourceTypeI
 
 
 
-export function extractResourceMapForType<TResource extends ResourceJson = ResourceJson>(
-    resourcesByType: Partial<Record<ResourceTypeIdJson, TResource[]>>,
-    resourceTypeId: ResourceTypeIdJson
-): Map<ResourceIdJson, TResource> {
+export function extractResourceMapForType<TResource extends Resource = Resource>(
+    resourcesByType: Partial<Record<ResourceTypeId, TResource[]>>,
+    resourceTypeId: ResourceTypeId
+): Map<ResourceId, TResource> {
     const resources = resourcesByType[resourceTypeId] ?? [];
-    const map = new Map<ResourceIdJson, TResource>();
+    const map = new Map<ResourceId, TResource>();
 
     for (const resource of resources) {
         map.set(resource.id, resource);
@@ -124,10 +124,10 @@ export function extractResourceMapForType<TResource extends ResourceJson = Resou
 export function extractIdKeyedNucleusMapForType<
     TKey extends string = string,
     TNucleus extends { id: string | number | boolean } = { id: string | number | boolean },
-    TResource extends ResourceJson = ResourceJson
+    TResource extends Resource = Resource
 >(
-    resourcesByType: Partial<Record<ResourceTypeIdJson, TResource[]>>,
-    resourceTypeId: ResourceTypeIdJson,
+    resourcesByType: Partial<Record<ResourceTypeId, TResource[]>>,
+    resourceTypeId: ResourceTypeId,
 ): Map<TKey, TNucleus> {
     const resourceMap = extractResourceMapForType<TResource>(resourcesByType, resourceTypeId);
     const out = new Map<TKey, TNucleus>();