@toolproof-core/genesis 1.0.52 → 1.0.54

package/dist/generated-src/declarations/booleans.d.ts

@@ -0,0 +1,2 @@
+import declarations from './booleans.json';
+export default declarations;

package/{generated-src → dist/generated-src}/declarations/booleans.json

@@ -1,4 +1,4 @@
 [
     false,
     true
-]
+]

package/dist/generated-src/declarations/naturals.d.ts

@@ -0,0 +1,2 @@
+import declarations from './naturals.json';
+export default declarations;

package/{generated-src → dist/generated-src}/declarations/naturals.json

@@ -10,4 +10,4 @@
     8,
     9,
     100
-]
+]

package/dist/generated-src/declarations/resourceTypes.d.ts

@@ -0,0 +1,2 @@
+import declarations from './resourceTypes.json';
+export default declarations;

package/{generated-src → dist/generated-src}/declarations/resourceTypes.json

@@ -509,4 +509,4 @@
             "unevaluatedProperties": false
         }
     }
-]
+]

package/dist/generated-src/declarations/tools.d.ts

@@ -0,0 +1,2 @@
+import declarations from './tools.json';
+export default declarations;

package/{generated-src → dist/generated-src}/declarations/tools.json

@@ -702,4 +702,4 @@
             }
         }
     }
-]
+]

package/dist/generated-src/implementations/tools.d.ts

@@ -0,0 +1,100 @@
+import type { Boolean, Natural, ResourceType, Tool } from '../types/types.js';
+type GenericAssignmentByRoleName<GenericRoleName extends string> = Record<GenericRoleName, ResourceType>;
+type InstantiationToolHandleBySpecializationKey = Record<string, Tool>;
+type TemplateInputs<GenericRoleName extends string> = {
+    GenericAssignmentByRoleName: GenericAssignmentByRoleName<GenericRoleName>;
+    InstantiationToolHandleBySpecializationKey: InstantiationToolHandleBySpecializationKey;
+};
+type TemplateOutputs = {
+    InstantiationTool: Tool;
+};
+type OperandTemplateInputs = TemplateInputs<'OperandType'>;
+export declare function createSpecializationKey(assignments: Record<string, ResourceType>): string;
+export declare function Identity(inputs: OperandTemplateInputs): TemplateOutputs;
+export declare function Add(inputs: OperandTemplateInputs): TemplateOutputs;
+export declare function Subtract(inputs: OperandTemplateInputs): TemplateOutputs;
+export declare function Multiply(inputs: OperandTemplateInputs): TemplateOutputs;
+export declare function Divide(inputs: OperandTemplateInputs): TemplateOutputs;
+export declare function Double(inputs: OperandTemplateInputs): TemplateOutputs;
+export declare function LessThan(inputs: OperandTemplateInputs): TemplateOutputs;
+export declare function BooleanIdentity(inputs: {
+    In: Boolean;
+}): {
+    Out: Boolean;
+};
+export declare function NaturalIdentity(inputs: {
+    In: Natural;
+}): {
+    Out: Natural;
+};
+export declare function NaturalLessThan(inputs: {
+    LessThanSource: Natural;
+    LessThanTarget: Natural;
+}): {
+    LessThanDecision: Boolean;
+};
+export declare function NaturalAdd(inputs: {
+    AddendOne: Natural;
+    AddendTwo: Natural;
+}): {
+    Sum: Natural;
+};
+export declare function NaturalSubtract(inputs: {
+    Minuend: Natural;
+    Subtrahend: Natural;
+}): {
+    Difference: Natural;
+};
+export declare function NaturalMultiply(inputs: {
+    Multiplicand: Natural;
+    Multiplier: Natural;
+}): {
+    Product: Natural;
+};
+export declare function NaturalDivide(inputs: {
+    Dividend: Natural;
+    Divisor: Natural;
+}): {
+    Quotient: Natural;
+    Remainder: Natural;
+};
+export declare function NaturalDouble(inputs: {
+    N: Natural;
+}): {
+    Doubled: Natural;
+};
+export declare const TOOL_IMPLEMENTATION_BY_NAME: {
+    readonly Identity: typeof Identity;
+    readonly Add: typeof Add;
+    readonly Subtract: typeof Subtract;
+    readonly Multiply: typeof Multiply;
+    readonly Divide: typeof Divide;
+    readonly Double: typeof Double;
+    readonly LessThan: typeof LessThan;
+    readonly BooleanIdentity: typeof BooleanIdentity;
+    readonly NaturalIdentity: typeof NaturalIdentity;
+    readonly NaturalLessThan: typeof NaturalLessThan;
+    readonly NaturalAdd: typeof NaturalAdd;
+    readonly NaturalSubtract: typeof NaturalSubtract;
+    readonly NaturalMultiply: typeof NaturalMultiply;
+    readonly NaturalDivide: typeof NaturalDivide;
+    readonly NaturalDouble: typeof NaturalDouble;
+};
+export declare const TOOL_IMPLEMENTATION_BY_HANDLE: {
+    readonly 'TOOL-Identity': typeof Identity;
+    readonly 'TOOL-Add': typeof Add;
+    readonly 'TOOL-Subtract': typeof Subtract;
+    readonly 'TOOL-Multiply': typeof Multiply;
+    readonly 'TOOL-Divide': typeof Divide;
+    readonly 'TOOL-Double': typeof Double;
+    readonly 'TOOL-LessThan': typeof LessThan;
+    readonly 'TOOL-BooleanIdentity': typeof BooleanIdentity;
+    readonly 'TOOL-NaturalIdentity': typeof NaturalIdentity;
+    readonly 'TOOL-NaturalLessThan': typeof NaturalLessThan;
+    readonly 'TOOL-NaturalAdd': typeof NaturalAdd;
+    readonly 'TOOL-NaturalSubtract': typeof NaturalSubtract;
+    readonly 'TOOL-NaturalMultiply': typeof NaturalMultiply;
+    readonly 'TOOL-NaturalDivide': typeof NaturalDivide;
+    readonly 'TOOL-NaturalDouble': typeof NaturalDouble;
+};
+export {};

package/dist/generated-src/implementations/tools.js

@@ -0,0 +1,135 @@
+const OPERAND_TYPE_ROLE_NAMES = ['OperandType'];
+function assertExactKeys(actualKeys, expectedKeys, label) {
+    const sortedActualKeys = [...actualKeys].sort();
+    const sortedExpectedKeys = [...expectedKeys].sort();
+    if (sortedActualKeys.length !== sortedExpectedKeys.length) {
+        throw new Error(`${label} must contain exactly [${sortedExpectedKeys.join(', ')}], got [${sortedActualKeys.join(', ')}]`);
+    }
+    for (let index = 0; index < sortedExpectedKeys.length; index += 1) {
+        if (sortedActualKeys[index] !== sortedExpectedKeys[index]) {
+            throw new Error(`${label} must contain exactly [${sortedExpectedKeys.join(', ')}], got [${sortedActualKeys.join(', ')}]`);
+        }
+    }
+}
+function asNatural(value, label) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative integer, got ${value}`);
+    }
+    return value;
+}
+export function createSpecializationKey(assignments) {
+    return JSON.stringify(Object.entries(assignments)
+        .sort(([leftRoleName], [rightRoleName]) => leftRoleName.localeCompare(rightRoleName))
+        .map(([roleName, resourceType]) => [roleName, resourceType.handle]));
+}
+function resolveTemplateInstantiation(inputs, expectedGenericRoleNames) {
+    const { GenericAssignmentByRoleName, InstantiationToolHandleBySpecializationKey } = inputs;
+    assertExactKeys(Object.keys(GenericAssignmentByRoleName), expectedGenericRoleNames, 'GenericAssignmentByRoleName');
+    const specializationKey = createSpecializationKey(GenericAssignmentByRoleName);
+    const instantiationTool = InstantiationToolHandleBySpecializationKey[specializationKey];
+    if (!instantiationTool) {
+        throw new Error(`No instantiation tool registered for specializationKey ${specializationKey}`);
+    }
+    return {
+        InstantiationTool: instantiationTool,
+    };
+}
+export function Identity(inputs) {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+export function Add(inputs) {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+export function Subtract(inputs) {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+export function Multiply(inputs) {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+export function Divide(inputs) {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+export function Double(inputs) {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+export function LessThan(inputs) {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+export function BooleanIdentity(inputs) {
+    return {
+        Out: inputs.In,
+    };
+}
+export function NaturalIdentity(inputs) {
+    return {
+        Out: inputs.In,
+    };
+}
+export function NaturalLessThan(inputs) {
+    return {
+        LessThanDecision: inputs.LessThanSource < inputs.LessThanTarget,
+    };
+}
+export function NaturalAdd(inputs) {
+    return {
+        Sum: asNatural(inputs.AddendOne + inputs.AddendTwo, 'Sum'),
+    };
+}
+export function NaturalSubtract(inputs) {
+    return {
+        Difference: asNatural(inputs.Minuend - inputs.Subtrahend, 'Difference'),
+    };
+}
+export function NaturalMultiply(inputs) {
+    return {
+        Product: asNatural(inputs.Multiplicand * inputs.Multiplier, 'Product'),
+    };
+}
+export function NaturalDivide(inputs) {
+    if (inputs.Divisor === 0) {
+        throw new Error('Divisor must be non-zero');
+    }
+    return {
+        Quotient: asNatural(Math.floor(inputs.Dividend / inputs.Divisor), 'Quotient'),
+        Remainder: asNatural(inputs.Dividend % inputs.Divisor, 'Remainder'),
+    };
+}
+export function NaturalDouble(inputs) {
+    return {
+        Doubled: asNatural(inputs.N * 2, 'Doubled'),
+    };
+}
+export const TOOL_IMPLEMENTATION_BY_NAME = {
+    Identity,
+    Add,
+    Subtract,
+    Multiply,
+    Divide,
+    Double,
+    LessThan,
+    BooleanIdentity,
+    NaturalIdentity,
+    NaturalLessThan,
+    NaturalAdd,
+    NaturalSubtract,
+    NaturalMultiply,
+    NaturalDivide,
+    NaturalDouble,
+};
+export const TOOL_IMPLEMENTATION_BY_HANDLE = {
+    'TOOL-Identity': Identity,
+    'TOOL-Add': Add,
+    'TOOL-Subtract': Subtract,
+    'TOOL-Multiply': Multiply,
+    'TOOL-Divide': Divide,
+    'TOOL-Double': Double,
+    'TOOL-LessThan': LessThan,
+    'TOOL-BooleanIdentity': BooleanIdentity,
+    'TOOL-NaturalIdentity': NaturalIdentity,
+    'TOOL-NaturalLessThan': NaturalLessThan,
+    'TOOL-NaturalAdd': NaturalAdd,
+    'TOOL-NaturalSubtract': NaturalSubtract,
+    'TOOL-NaturalMultiply': NaturalMultiply,
+    'TOOL-NaturalDivide': NaturalDivide,
+    'TOOL-NaturalDouble': NaturalDouble,
+};

package/dist/generated-src/lookups/constants.d.ts

@@ -0,0 +1,195 @@
+declare const CONSTANTS: {
+    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 DeferredStrategyProvenance: "DeferredStrategyProvenance";
+        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 OutputAddress: "OutputAddress";
+        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 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 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 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 default CONSTANTS;

package/{generated-src/lookups/constants.ts → dist/generated-src/lookups/constants.js}

@@ -92,6 +92,73 @@ const CONSTANTS = {
         UnthreadedToolStepPathSpec: 'UnthreadedToolStepPathSpec',
         WhileStep: 'WhileStep',
     },
+    Handles: {
+        ResourceTypes: {
+            TYPE_Boolean: 'TYPE-Boolean',
+            TYPE_Error: 'TYPE-Error',
+            TYPE_Goal: 'TYPE-Goal',
+            TYPE_Natural: 'TYPE-Natural',
+            TYPE_Resource: 'TYPE-Resource',
+            TYPE_ResourceType: 'TYPE-ResourceType',
+            TYPE_Strategy: 'TYPE-Strategy',
+            TYPE_StrategyTrace: 'TYPE-StrategyTrace',
+            TYPE_Suite: 'TYPE-Suite',
+            TYPE_Tool: 'TYPE-Tool',
+        },
+        Tools: {
+            TOOL_Add: 'TOOL-Add',
+            TOOL_BooleanIdentity: 'TOOL-BooleanIdentity',
+            TOOL_Divide: 'TOOL-Divide',
+            TOOL_Double: 'TOOL-Double',
+            TOOL_Identity: 'TOOL-Identity',
+            TOOL_LessThan: 'TOOL-LessThan',
+            TOOL_Multiply: 'TOOL-Multiply',
+            TOOL_NaturalAdd: 'TOOL-NaturalAdd',
+            TOOL_NaturalDivide: 'TOOL-NaturalDivide',
+            TOOL_NaturalDouble: 'TOOL-NaturalDouble',
+            TOOL_NaturalIdentity: 'TOOL-NaturalIdentity',
+            TOOL_NaturalLessThan: 'TOOL-NaturalLessThan',
+            TOOL_NaturalMultiply: 'TOOL-NaturalMultiply',
+            TOOL_NaturalSubtract: 'TOOL-NaturalSubtract',
+            TOOL_Subtract: 'TOOL-Subtract',
+        },
+    },
+    ToolRoleNames: {
+        TOOL_Add: {
+            AddendOne: 'AddendOne',
+            AddendTwo: 'AddendTwo',
+            Sum: 'Sum',
+        },
+        TOOL_Divide: {
+            Dividend: 'Dividend',
+            Divisor: 'Divisor',
+            Quotient: 'Quotient',
+            Remainder: 'Remainder',
+        },
+        TOOL_Double: {
+            Doubled: 'Doubled',
+            N: 'N',
+        },
+        TOOL_Identity: {
+            In: 'In',
+            Out: 'Out',
+        },
+        TOOL_LessThan: {
+            LessThanDecision: 'LessThanDecision',
+            LessThanSource: 'LessThanSource',
+            LessThanTarget: 'LessThanTarget',
+        },
+        TOOL_Multiply: {
+            Multiplicand: 'Multiplicand',
+            Multiplier: 'Multiplier',
+            Product: 'Product',
+        },
+        TOOL_Subtract: {
+            Difference: 'Difference',
+            Minuend: 'Minuend',
+            Subtrahend: 'Subtrahend',
+        },
+    },
     Enums: {
         ContainerKind: {
             scalar: 'scalar',
@@ -124,6 +191,5 @@ const CONSTANTS = {
             graph_end: 'graph_end',
         },
     }
-} as const;
-
+};
 export default CONSTANTS;

package/dist/generated-src/lookups/mappings.d.ts

@@ -0,0 +1,11 @@
+declare const MAPPINGS: {
+    readonly IdentifierNameToPrefix: {
+        readonly GoalHandle: "GOAL-";
+        readonly ResourceId: "RESOURCE-";
+        readonly ResourceTypeHandle: "TYPE-";
+        readonly StrategyHandle: "STRATEGY-";
+        readonly StrategyTraceHandle: "STRATEGY_TRACE-";
+        readonly ToolHandle: "TOOL-";
+    };
+};
+export default MAPPINGS;

package/{generated-src/lookups/mappings.ts → dist/generated-src/lookups/mappings.js}

@@ -1,5 +1,5 @@
 const MAPPINGS = {
-    HandleNameToPrefix: {
+    IdentifierNameToPrefix: {
         GoalHandle: 'GOAL-',
         ResourceId: 'RESOURCE-',
         ResourceTypeHandle: 'TYPE-',
@@ -7,6 +7,5 @@ const MAPPINGS = {
         StrategyTraceHandle: 'STRATEGY_TRACE-',
         ToolHandle: 'TOOL-',
     },
-} as const;
-
+};
 export default MAPPINGS;

package/dist/generated-src/schemas/schemas.d.ts

@@ -0,0 +1,2 @@
+import schema from './schemas.json';
+export default schema;

package/{generated-src → dist/generated-src}/schemas/schemas.json

@@ -1836,4 +1836,4 @@
             "unevaluatedProperties": false
         }
     }
-}
+}

package/dist/generated-src/schemas/standalone/Boolean.d.ts

@@ -0,0 +1,2 @@
+import schema from './Boolean.json';
+export default schema;

package/dist/generated-src/schemas/standalone/Boolean.json

@@ -0,0 +1,5 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "boolean",
+    "$defs": {}
+}

package/dist/generated-src/schemas/standalone/Error.d.ts

@@ -0,0 +1,2 @@
+import schema from './Error.json';
+export default schema;