@toolproof-core/genesis 1.0.49 → 1.0.50

package/generated-src/schemas/standalone/Suite.json

@@ -0,0 +1,646 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "allOf": [
+    {
+      "type": "object",
+      "required": [
+        "name",
+        "version",
+        "description"
+      ],
+      "properties": {
+        "name": {
+          "$ref": "#/$defs/Name"
+        },
+        "version": {
+          "type": "string",
+          "minLength": 1
+        },
+        "description": {
+          "$ref": "#/$defs/Description"
+        }
+      }
+    },
+    {
+      "type": "object",
+      "required": [
+        "resourceTypes",
+        "tools"
+      ],
+      "properties": {
+        "resourceTypes": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/ResourceType"
+          },
+          "uniqueItems": true
+        },
+        "tools": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/Tool"
+          },
+          "uniqueItems": true
+        }
+      }
+    }
+  ],
+  "unevaluatedProperties": false,
+  "$defs": {
+    "Name": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "string",
+      "minLength": 1,
+      "pattern": "^[A-Z][a-zA-Z0-9]*$",
+      "$comment": "Validation is intercepted by an AI Agent that verifies the name against Toolproof's naming conventions.",
+      "semanticValidation": "Ajv custom keyword to verify name."
+    },
+    "Description": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "string",
+      "minLength": 1,
+      "$comment": "Validation is intercepted by an AI Agent that verifies the description against Toolproof's documentation standards.",
+      "semanticValidation": "Ajv custom keyword to verify description."
+    },
+    "ResourceType": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "required": [
+        "handle"
+      ],
+      "semanticValidation": "If ingestorToolHandle is present, verify that it references an existing non-template Tool whose distinguished raw-instance input semantically matches ingestorToolInputSchema when provided, whose distinguished Boolean output reports whether the raw instance is valid for this ResourceType, and whose distinguished projection output is typed as this ResourceType and conforms to projectionSchema when projectionSchema is present.",
+      "properties": {
+        "handle": {
+          "$ref": "#/$defs/ResourceTypeHandle"
+        },
+        "projectionSchema": {
+          "$ref": "#/$defs/JsonSchemaObject"
+        },
+        "ingestorToolHandle": {
+          "$ref": "#/$defs/ToolHandle"
+        },
+        "ingestorToolInputSchema": {
+          "$ref": "#/$defs/JsonSchemaObject"
+        },
+        "embeddingModelTools": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/ToolHandle"
+          },
+          "minItems": 1,
+          "$comment": "A ResourceType may specify a set of embeddingModelTools that convert the raw data (or one of its alternative representations) into vector embeddings. The build process enforces that the entries are members of a set of predefined embeddingModelTools."
+        }
+      },
+      "allOf": [
+        {
+          "$ref": "#/$defs/DocumentationSpec"
+        },
+        {
+          "$comment": "A ResourceType ultimately describes both raw instances and their Core-visible JSON projection. Inside ToolProof Core, the ResourceType denotes the projection. projectionSchema describes the shape of that Core-visible projection. ingestorToolHandle identifies the Tool that ingests raw instances for this ResourceType by validating them against the built-in format grammar and, when projectionSchema is present, emitting the corresponding projection for Core. ingestorToolInputSchema describes the raw-instance input accepted by that ingestor. A ResourceType must specify either a projectionSchema or an ingestorToolHandle, or both. If only a projectionSchema is specified, the author relies on schema-based validation of the Core-visible projection and does not designate an ingestor. If only an ingestorToolHandle is specified, the author designates an ingestor that is authoritative for validating raw instances of the ResourceType. If both are specified, the ingestor must emit projections that conform to projectionSchema.",
+          "anyOf": [
+            {
+              "required": [
+                "projectionSchema"
+              ]
+            },
+            {
+              "required": [
+                "ingestorToolHandle"
+              ]
+            }
+          ]
+        },
+        {
+          "if": {
+            "required": [
+              "ingestorToolInputSchema"
+            ]
+          },
+          "then": {
+            "required": [
+              "ingestorToolHandle"
+            ]
+          }
+        }
+      ],
+      "unevaluatedProperties": false
+    },
+    "Tool": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "required": [
+        "handle",
+        "isTemplate"
+      ],
+      "properties": {
+        "handle": {
+          "$ref": "#/$defs/ToolHandle"
+        },
+        "templateToolHandle": {
+          "$ref": "#/$defs/ToolHandle"
+        },
+        "isTemplate": {
+          "type": "boolean"
+        },
+        "instantiationRoleSpec": {
+          "$ref": "#/$defs/RoleSpec"
+        }
+      },
+      "$comment": "Template Tools own dispatch contract: Core scans all instantiation Tools grouped by templateToolHandle, derives a specializationKey from each instantiation tool's generic assignment by taking the canonical order of genericRoleName -> assigned ResourceType.resourceTypeHandle pairs, and asserts injectivity (no two instantiation Tools share the same key for the same template). At invocation time Core injects the specializationKey -> instantiationToolHandle lookup as the second input, then the template resolves the first input against it to return one instantiation Tool. Cross-resource compatibility between an instantiation Tool's roleSpec and the template's instantiationRoleSpec is deferred to the validation package.",
+      "semanticValidation": "Deferred: verify injectivity of specializationKey map per template; verify instantiation Tool roleSpec matches template instantiationRoleSpec; verify every supplied generic assignment key-set exactly equals roleSpec.inputRoleValueByName.GenericAssignmentByRoleName.mapKeys; verify every supplied generic assignment matches a registered specializationKey.",
+      "allOf": [
+        {
+          "$ref": "#/$defs/DocumentationSpec"
+        },
+        {
+          "if": {
+            "required": [
+              "isTemplate"
+            ],
+            "properties": {
+              "isTemplate": {
+                "const": true
+              }
+            }
+          },
+          "then": {
+            "required": [
+              "instantiationRoleSpec"
+            ]
+          },
+          "else": {
+            "not": {
+              "required": [
+                "instantiationRoleSpec"
+              ]
+            }
+          }
+        },
+        {
+          "$comment": "Template Tools must declare named roles: two map inputs (GenericAssignmentByRoleName and InstantiationToolHandleBySpecializationKey) and one scalar TYPE-Tool output (InstantiationTool). GenericAssignmentByRoleName.mapKeys declares the generic parameter names accepted by the template. Runtime semantic validation enforces that each invocation's GenericAssignmentByRoleName object has exactly that key set: no missing keys, no extra keys. These keys are the generic parameter names later referenced via roleSchema refs such as #OperandType; they are not required to match the top-level role names of instantiationRoleSpec.",
+          "if": {
+            "required": [
+              "isTemplate"
+            ],
+            "properties": {
+              "isTemplate": {
+                "const": true
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "roleSpec": {
+                "properties": {
+                  "inputRoleValueByName": {
+                    "required": [
+                      "GenericAssignmentByRoleName",
+                      "InstantiationToolHandleBySpecializationKey"
+                    ],
+                    "properties": {
+                      "GenericAssignmentByRoleName": {
+                        "required": [
+                          "containerKind",
+                          "typeRef",
+                          "mapKeys"
+                        ],
+                        "properties": {
+                          "containerKind": {
+                            "const": "map"
+                          },
+                          "typeRef": {
+                            "required": [
+                              "resourceTypeHandle"
+                            ],
+                            "properties": {
+                              "resourceTypeHandle": {
+                                "const": "TYPE-ResourceType"
+                              }
+                            }
+                          },
+                          "mapKeys": {
+                            "type": "array",
+                            "items": {
+                              "$ref": "#/$defs/RoleName"
+                            },
+                            "minItems": 1,
+                            "uniqueItems": true
+                          }
+                        }
+                      },
+                      "InstantiationToolHandleBySpecializationKey": {
+                        "required": [
+                          "containerKind",
+                          "typeRef"
+                        ],
+                        "properties": {
+                          "containerKind": {
+                            "const": "map"
+                          },
+                          "typeRef": {
+                            "required": [
+                              "resourceTypeHandle"
+                            ],
+                            "properties": {
+                              "resourceTypeHandle": {
+                                "const": "TYPE-Tool"
+                              }
+                            }
+                          }
+                        },
+                        "not": {
+                          "required": [
+                            "mapKeys"
+                          ]
+                        }
+                      }
+                    },
+                    "additionalProperties": false
+                  },
+                  "outputRoleValueByName": {
+                    "required": [
+                      "InstantiationTool"
+                    ],
+                    "properties": {
+                      "InstantiationTool": {
+                        "required": [
+                          "containerKind",
+                          "typeRef"
+                        ],
+                        "properties": {
+                          "containerKind": {
+                            "const": "scalar"
+                          },
+                          "typeRef": {
+                            "required": [
+                              "resourceTypeHandle"
+                            ],
+                            "properties": {
+                              "resourceTypeHandle": {
+                                "const": "TYPE-Tool"
+                              }
+                            }
+                          }
+                        }
+                      }
+                    },
+                    "additionalProperties": false
+                  }
+                }
+              }
+            }
+          }
+        },
+        {
+          "$ref": "#/$defs/RoleSpecFacet"
+        }
+      ],
+      "unevaluatedProperties": false
+    },
+    "ResourceTypeHandle": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "string",
+      "pattern": "^TYPE-.+$"
+    },
+    "JsonSchemaObject": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "required": [
+        "$schema"
+      ],
+      "properties": {
+        "$schema": {
+          "const": "https://json-schema.org/draft/2020-12/schema"
+        }
+      },
+      "additionalProperties": true
+    },
+    "ToolHandle": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "string",
+      "pattern": "^TOOL-.+$"
+    },
+    "DocumentationSpec": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "allOf": [
+        {
+          "$ref": "#/$defs/NameFacet"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "symbol": {
+              "type": "string"
+            }
+          }
+        },
+        {
+          "$ref": "#/$defs/DescriptionFacet"
+        }
+      ]
+    },
+    "RoleSpec": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "required": [
+        "inputRoleValueByName",
+        "outputRoleValueByName"
+      ],
+      "properties": {
+        "inputRoleValueByName": {
+          "$ref": "#/$defs/RoleValueByName"
+        },
+        "outputRoleValueByName": {
+          "$ref": "#/$defs/RoleValueByName"
+        },
+        "refinementSchema": {
+          "$comment": "Allows Tool authors to specify additional constraints on the role assignment beyond those expressible in the type system.",
+          "$ref": "#/$defs/JsonSchemaObject"
+        }
+      },
+      "unevaluatedProperties": false
+    },
+    "RoleName": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "$ref": "#/$defs/Name"
+    },
+    "RoleSpecFacet": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "required": [
+        "roleSpec"
+      ],
+      "properties": {
+        "roleSpec": {
+          "$ref": "#/$defs/RoleSpec"
+        }
+      }
+    },
+    "NameFacet": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "required": [
+        "name"
+      ],
+      "properties": {
+        "name": {
+          "$ref": "#/$defs/Name"
+        }
+      }
+    },
+    "DescriptionFacet": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "required": [
+        "description"
+      ],
+      "properties": {
+        "description": {
+          "$ref": "#/$defs/Description"
+        }
+      }
+    },
+    "RoleValueByName": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "object",
+      "propertyNames": {
+        "$ref": "#/$defs/RoleName"
+      },
+      "additionalProperties": {
+        "$ref": "#/$defs/RoleValue"
+      }
+    },
+    "RoleValue": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "$comment": "Pairs a type reference (typeRef) with a container shape. typeRef may be a single atomic type reference or a finite sum type over atomic successful value alternatives.",
+      "type": "object",
+      "required": [
+        "typeRef",
+        "containerKind"
+      ],
+      "properties": {
+        "typeRef": {
+          "$ref": "#/$defs/TypeRef"
+        },
+        "refinementSchema": {
+          "$comment": "Allows Tool authors to specify additional constraints on the role value beyond those expressible in the type system.",
+          "$ref": "#/$defs/JsonSchemaObject"
+        },
+        "containerKind": {
+          "$ref": "#/$defs/ContainerKind"
+        },
+        "containerSchema": {
+          "$ref": "#/$defs/JsonSchemaObject"
+        },
+        "mapKeys": {
+          "$ref": "#/$defs/RoleNameArray"
+        }
+      },
+      "allOf": [
+        {
+          "$comment": "If containerKind is scalar, containerSchema is forbidden. Otherwise, it is optional.",
+          "if": {
+            "properties": {
+              "containerKind": {
+                "const": "scalar"
+              }
+            }
+          },
+          "then": {
+            "not": {
+              "required": [
+                "containerSchema"
+              ]
+            }
+          }
+        },
+        {
+          "$comment": "If containerKind is array and containerSchema is provided, it must describe a homogeneous array (type=array with items; tuple-only schemas are disallowed).",
+          "if": {
+            "required": [
+              "containerSchema"
+            ],
+            "properties": {
+              "containerKind": {
+                "const": "array"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "containerSchema": {
+                "type": "object",
+                "required": [
+                  "type",
+                  "items"
+                ],
+                "properties": {
+                  "type": {
+                    "const": "array"
+                  },
+                  "items": {
+                    "type": "object"
+                  }
+                },
+                "not": {
+                  "required": [
+                    "prefixItems"
+                  ]
+                }
+              }
+            }
+          }
+        },
+        {
+          "$comment": "If containerKind is map and containerSchema is provided, it must describe a homogeneous map (type=object with additionalProperties; key-specific schemas are disallowed).",
+          "if": {
+            "required": [
+              "containerSchema"
+            ],
+            "properties": {
+              "containerKind": {
+                "const": "map"
+              }
+            }
+          },
+          "then": {
+            "properties": {
+              "containerSchema": {
+                "type": "object",
+                "required": [
+                  "type",
+                  "additionalProperties"
+                ],
+                "properties": {
+                  "type": {
+                    "const": "object"
+                  },
+                  "additionalProperties": {
+                    "type": "object"
+                  }
+                },
+                "not": {
+                  "anyOf": [
+                    {
+                      "required": [
+                        "properties"
+                      ]
+                    },
+                    {
+                      "required": [
+                        "patternProperties"
+                      ]
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        },
+        {
+          "$comment": "If containerKind is map, mapKeys is optional (omit for open/dynamic keys, supply for statically-known fixed keys). On non-map containers, mapKeys is forbidden.",
+          "if": {
+            "properties": {
+              "containerKind": {
+                "const": "map"
+              }
+            }
+          },
+          "then": {},
+          "else": {
+            "not": {
+              "required": [
+                "mapKeys"
+              ]
+            }
+          }
+        }
+      ],
+      "unevaluatedProperties": false
+    },
+    "TypeRef": {
+      "$comment": "A type reference is either a single AtomicTypeRef or a finite sum type expressed as oneOfTypeRefs. The oneOfTypeRefs branch permits a union of atomic successful value alternatives and does not permit nested unions.",
+      "oneOf": [
+        {
+          "$ref": "#/$defs/AtomicTypeRef"
+        },
+        {
+          "type": "object",
+          "required": [
+            "oneOfTypeRefs"
+          ],
+          "properties": {
+            "oneOfTypeRefs": {
+              "type": "array",
+              "items": {
+                "$ref": "#/$defs/AtomicTypeRef"
+              },
+              "minItems": 2,
+              "uniqueItems": true
+            }
+          },
+          "additionalProperties": false
+        }
+      ]
+    },
+    "ContainerKind": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "string",
+      "enum": [
+        "scalar",
+        "array",
+        "map"
+      ]
+    },
+    "RoleNameArray": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/RoleName"
+      }
+    },
+    "AtomicTypeRef": {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "$comment": "An atomic type reference is either resource-backed (resourceTypeHandle, strategy-legal) or schema-backed (roleSchema, internal/Core-only). The roleSchema branch holds an object whose $ref names the type parameter (e.g. '#OperandType'), matching an entry in the template's GenericAssignmentByRoleName.mapKeys. Exactly one atomic branch must be present.",
+      "oneOf": [
+        {
+          "type": "object",
+          "required": [
+            "resourceTypeHandle"
+          ],
+          "properties": {
+            "resourceTypeHandle": {
+              "$ref": "#/$defs/ResourceTypeHandle"
+            }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": [
+            "roleSchema"
+          ],
+          "properties": {
+            "roleSchema": {
+              "type": "object",
+              "required": [
+                "$ref"
+              ],
+              "$comment": "A reference to a named type parameter. The $ref value must be '#' followed by a RoleName, matching a key in the template's GenericAssignmentByRoleName.mapKeys.",
+              "properties": {
+                "$ref": {
+                  "type": "string",
+                  "pattern": "^#[A-Z][a-zA-Z0-9]*$"
+                }
+              },
+              "additionalProperties": false
+            }
+          },
+          "additionalProperties": false
+        }
+      ]
+    }
+  }
+}

package/generated-src/schemas/standalone/Suite.ts

@@ -0,0 +1,2 @@
+import schema from './Suite.json' with { type: 'json' };
+export default schema;