@toolproof-core/genesis 1.0.52 → 1.0.54

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

@@ -1,533 +0,0 @@
-{
-  "$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,
-  "$defs": {
-    "ToolHandle": {
-      "$schema": "https://json-schema.org/draft/2020-12/schema",
-      "type": "string",
-      "pattern": "^TOOL-.+$"
-    },
-    "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
-    },
-    "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"
-        }
-      ]
-    },
-    "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"
-        }
-      }
-    },
-    "RoleValueByName": {
-      "$schema": "https://json-schema.org/draft/2020-12/schema",
-      "type": "object",
-      "propertyNames": {
-        "$ref": "#/$defs/RoleName"
-      },
-      "additionalProperties": {
-        "$ref": "#/$defs/RoleValue"
-      }
-    },
-    "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
-    },
-    "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"
-        }
-      }
-    },
-    "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."
-    },
-    "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
-    },
-    "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."
-    },
-    "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
-        }
-      ]
-    },
-    "ResourceTypeHandle": {
-      "$schema": "https://json-schema.org/draft/2020-12/schema",
-      "type": "string",
-      "pattern": "^TYPE-.+$"
-    }
-  }
-}

package/generated-src/schemas/zod/Error.ts

@@ -1,11 +0,0 @@
-// Auto-generated from standalone schema 'Error'. Do not edit.
-import { z } from 'zod/v4';
-
-
-const DescriptionSchema: z.ZodTypeAny = z.lazy(() => z.string().min(1));
-const DescriptionFacetSchema: z.ZodTypeAny = z.lazy(() => z.object({ "description": DescriptionSchema }));
-const DocumentationSpecSchema: z.ZodTypeAny = z.lazy(() => z.object({ "name": NameSchema, "symbol": z.string().optional(), "description": DescriptionSchema }));
-const NameSchema: z.ZodTypeAny = z.lazy(() => z.string().min(1).regex(new RegExp("^[A-Z][a-zA-Z0-9]*$")));
-const NameFacetSchema: z.ZodTypeAny = z.lazy(() => z.object({ "name": NameSchema }));
-
-export const ErrorSchema: z.ZodTypeAny = z.lazy(() => z.object({ "name": NameSchema, "symbol": z.string().optional(), "description": DescriptionSchema, "details": z.object({  }).optional() }).strict());

package/generated-src/schemas/zod/Goal.ts

@@ -1,8 +0,0 @@
-// Auto-generated from standalone schema 'Goal'. Do not edit.
-import { z } from 'zod/v4';
-
-
-const GoalHandleSchema: z.ZodTypeAny = z.lazy(() => z.string().regex(new RegExp("^GOAL-.+$")));
-const ToolHandleSchema: z.ZodTypeAny = z.lazy(() => z.string().regex(new RegExp("^TOOL-.+$")));
-
-export const GoalSchema: z.ZodTypeAny = z.lazy(() => z.object({ "handle": GoalHandleSchema, "target": z.number().int().min(0), "disallowedTools": z.array(ToolHandleSchema).optional(), "disallowedSequences": z.array(z.array(ToolHandleSchema)).optional(), "minSteps": z.number().int().min(1).optional(), "maxSteps": z.number().int().min(1).optional() }).strict());

package/generated-src/schemas/zod/Resource.ts

@@ -1,21 +0,0 @@
-// Auto-generated from standalone schema 'Resource'. Do not edit.
-import { z } from 'zod/v4';
-
-
-const BaseResourceSchema: z.ZodTypeAny = z.lazy(() => z.object({ "projection": z.any(), "id": ResourceIdSchema, "resourceTypeHandle": ResourceTypeHandleSchema, "provenance": ProvenanceSchema }).strict());
-const GenesisProvenanceSchema: z.ZodTypeAny = z.lazy(() => z.object({ "provenanceKind": z.literal("genesis") }).strict());
-const NameSchema: z.ZodTypeAny = z.lazy(() => z.string().min(1).regex(new RegExp("^[A-Z][a-zA-Z0-9]*$")));
-const OutputAddressSchema: z.ZodTypeAny = z.lazy(() => z.object({ "roleName": RoleNameSchema, "toolStepPath": ToolStepPathSchema }).strict());
-const ProvenanceSchema: z.ZodTypeAny = z.lazy(() => z.union([GenesisProvenanceSchema, StrategyProvenanceSchema]));
-const ProvenanceFacetSchema: z.ZodTypeAny = z.lazy(() => z.object({ "provenance": ProvenanceSchema }));
-const ResourceIdSchema: z.ZodTypeAny = z.lazy(() => z.string().regex(new RegExp("^RESOURCE-.+$")));
-const ResourcePointerSchema: z.ZodTypeAny = z.lazy(() => z.object({ "id": ResourceIdSchema, "resourceTypeHandle": ResourceTypeHandleSchema, "provenance": ProvenanceSchema }).strict());
-const ResourceTypeHandleSchema: z.ZodTypeAny = z.lazy(() => z.string().regex(new RegExp("^TYPE-.+$")));
-const RoleNameSchema: z.ZodTypeAny = z.lazy(() => NameSchema);
-const StrategyProvenanceSchema: z.ZodTypeAny = z.lazy(() => z.object({ "provenanceKind": z.literal("strategy"), "strategyTraceHandle": StrategyTraceHandleSchema, "outputAddress": OutputAddressSchema }).strict());
-const StrategyTraceHandleSchema: z.ZodTypeAny = z.lazy(() => z.string().regex(new RegExp("^STRATEGY_TRACE-.+$")));
-const ThreadedToolStepPathSchema: z.ZodTypeAny = z.lazy(() => z.string().regex(new RegExp("^/threads/[0-9]+/steps/[0-9]+/(self|case/when|case/what|cases/[0-9]+/when|cases/[0-9]+/what)$")));
-const ToolStepPathSchema: z.ZodTypeAny = z.lazy(() => z.union([UnthreadedToolStepPathSchema, ThreadedToolStepPathSchema]));
-const UnthreadedToolStepPathSchema: z.ZodTypeAny = z.lazy(() => z.string().regex(new RegExp("^/steps/[0-9]+/(self|case/when|case/what|cases/[0-9]+/when|cases/[0-9]+/what)$")));
-
-export const ResourceSchema: z.ZodTypeAny = z.lazy(() => BaseResourceSchema);

package/generated-src/schemas/zod/ResourceType.ts

@@ -1,14 +0,0 @@
-// Auto-generated from standalone schema 'ResourceType'. Do not edit.
-import { z } from 'zod/v4';
-
-
-const DescriptionSchema: z.ZodTypeAny = z.lazy(() => z.string().min(1));
-const DescriptionFacetSchema: z.ZodTypeAny = z.lazy(() => z.object({ "description": DescriptionSchema }));
-const DocumentationSpecSchema: z.ZodTypeAny = z.lazy(() => z.object({ "name": NameSchema, "symbol": z.string().optional(), "description": DescriptionSchema }));
-const JsonSchemaObjectSchema: z.ZodTypeAny = z.lazy(() => z.object({ "$schema": z.literal("https://json-schema.org/draft/2020-12/schema") }).passthrough());
-const NameSchema: z.ZodTypeAny = z.lazy(() => z.string().min(1).regex(new RegExp("^[A-Z][a-zA-Z0-9]*$")));
-const NameFacetSchema: z.ZodTypeAny = z.lazy(() => z.object({ "name": NameSchema }));
-const ResourceTypeHandleSchema: z.ZodTypeAny = z.lazy(() => z.string().regex(new RegExp("^TYPE-.+$")));
-const ToolHandleSchema: z.ZodTypeAny = z.lazy(() => z.string().regex(new RegExp("^TOOL-.+$")));
-
-export const ResourceTypeSchema: z.ZodTypeAny = z.lazy(() => z.intersection(z.intersection(z.intersection(z.object({ "handle": ResourceTypeHandleSchema, "projectionSchema": JsonSchemaObjectSchema.optional(), "ingestorToolHandle": ToolHandleSchema.optional(), "ingestorToolInputSchema": JsonSchemaObjectSchema.optional(), "embeddingModelTools": z.array(ToolHandleSchema).min(1).optional() }).strict(), DocumentationSpecSchema), z.union([z.object({  }), z.object({  })])), z.any()));

package/generated-src/schemas/zod/Strategy.ts

@@ -1,68 +0,0 @@
-// Auto-generated from standalone schema 'Strategy'. Do not edit.
-import { z } from 'zod/v4';
-
-
-export const StrategyZodGenerationWarnings = [
-  {
-    "path": "$defs.StepArray.uniqueItems",
-    "message": "uniqueItems not enforced by generated Zod."
-  },
-  {
-    "path": "$defs.StrategyStateInputEntryByRoleName.propertyNames",
-    "message": "Unsupported propertyNames $ref target; keys will not be validated."
-  },
-  {
-    "path": "$defs.BranchStep.allOfMerged.properties.cases.uniqueItems",
-    "message": "uniqueItems not enforced by generated Zod."
-  }
-] as const;
-
-const BaseResourceSchema: z.ZodTypeAny = z.lazy(() => z.object({ "projection": z.any(), "id": ResourceIdSchema, "resourceTypeHandle": ResourceTypeHandleSchema, "provenance": ProvenanceSchema }).strict());
-const BaseStrategySchema: z.ZodTypeAny = z.lazy(() => z.object({ "handle": StrategyHandleSchema, "strategyKind": StrategyKindSchema }));
-const BranchStepSchema: z.ZodTypeAny = z.lazy(() => z.object({ "stepKind": z.intersection(z.literal("branch"), StepKindSchema), "cases": z.array(CaseSchema).min(1) }));
-const CaseSchema: z.ZodTypeAny = z.lazy(() => z.object({ "when": ToolStepSchema, "what": ToolStepSchema }).strict());
-const DeferredStrategyProvenanceSchema: z.ZodTypeAny = z.lazy(() => z.object({ "provenanceKind": z.literal("strategy"), "outputAddress": OutputAddressSchema }).strict());
-const ExternalInputPotentialSchema: z.ZodTypeAny = z.lazy(() => z.object({ "strategyStateInputKind": z.literal("externalInputPotential"), "id": ResourceIdSchema, "resourceTypeHandle": ResourceTypeHandleSchema }).strict());
-const ForStepSchema: z.ZodTypeAny = z.lazy(() => z.object({ "stepKind": z.intersection(z.literal("for"), StepKindSchema), "case": CaseSchema }));
-const GenesisProvenanceSchema: z.ZodTypeAny = z.lazy(() => z.object({ "provenanceKind": z.literal("genesis") }).strict());
-const InputPotentialSchema: z.ZodTypeAny = z.lazy(() => z.union([ExternalInputPotentialSchema, InternalInputPotentialSchema]));
-const InputResourceSchema: z.ZodTypeAny = z.lazy(() => z.object({ "strategyStateInputKind": z.literal("inputResource"), "projection": z.any(), "id": ResourceIdSchema, "resourceTypeHandle": ResourceTypeHandleSchema, "provenance": ProvenanceSchema }).strict());
-const InternalInputPotentialSchema: z.ZodTypeAny = z.lazy(() => z.object({ "strategyStateInputKind": z.literal("internalInputPotential"), "id": ResourceIdSchema, "resourceTypeHandle": ResourceTypeHandleSchema, "provenance": DeferredStrategyProvenanceSchema }).strict());
-const NameSchema: z.ZodTypeAny = z.lazy(() => z.string().min(1).regex(new RegExp("^[A-Z][a-zA-Z0-9]*$")));
-const OutputAddressSchema: z.ZodTypeAny = z.lazy(() => z.object({ "roleName": RoleNameSchema, "toolStepPath": ToolStepPathSchema }).strict());
-const ProvenanceSchema: z.ZodTypeAny = z.lazy(() => z.union([GenesisProvenanceSchema, StrategyProvenanceSchema]));
-const ProvenanceFacetSchema: z.ZodTypeAny = z.lazy(() => z.object({ "provenance": ProvenanceSchema }));
-const ResourceIdSchema: z.ZodTypeAny = z.lazy(() => z.string().regex(new RegExp("^RESOURCE-.+$")));
-const ResourcePointerSchema: z.ZodTypeAny = z.lazy(() => z.object({ "id": ResourceIdSchema, "resourceTypeHandle": ResourceTypeHandleSchema, "provenance": ProvenanceSchema }).strict());
-const ResourceTypeHandleSchema: z.ZodTypeAny = z.lazy(() => z.string().regex(new RegExp("^TYPE-.+$")));
-const RoleBindingSpecSchema: z.ZodTypeAny = z.lazy(() => z.object({ "inputBindings": RoleNameArraySchema, "outputBindings": RoleNameArraySchema }).strict());
-const RoleBindingSpecFacetSchema: z.ZodTypeAny = z.lazy(() => z.object({ "roleBindingSpec": RoleBindingSpecSchema }));
-const RoleNameSchema: z.ZodTypeAny = z.lazy(() => NameSchema);
-const RoleNameArraySchema: z.ZodTypeAny = z.lazy(() => z.array(RoleNameSchema));
-const StepSchema: z.ZodTypeAny = z.lazy(() => z.union([ToolStepSchema, BranchStepSchema, WhileStepSchema, ForStepSchema]));
-const StepArraySchema: z.ZodTypeAny = z.lazy(() => z.array(StepSchema));
-const StepArrayArraySchema: z.ZodTypeAny = z.lazy(() => z.array(StepArraySchema));
-const StepKindSchema: z.ZodTypeAny = z.lazy(() => z.union([z.literal("tool"), z.literal("branch"), z.literal("while"), z.literal("for")]));
-const StepKindFacetSchema: z.ZodTypeAny = z.lazy(() => z.object({ "stepKind": StepKindSchema }));
-const StepsByThreadIndexFacetSchema: z.ZodTypeAny = z.lazy(() => z.object({ "stepsByThreadIndex": StepArrayArraySchema }));
-const StepsFacetSchema: z.ZodTypeAny = z.lazy(() => z.object({ "steps": StepArraySchema }));
-const StrategyHandleSchema: z.ZodTypeAny = z.lazy(() => z.string().regex(new RegExp("^STRATEGY-.+$")));
-const StrategyKindSchema: z.ZodTypeAny = z.lazy(() => z.union([z.literal("unthreaded"), z.literal("threaded")]));
-const StrategyProvenanceSchema: z.ZodTypeAny = z.lazy(() => z.object({ "provenanceKind": z.literal("strategy"), "strategyTraceHandle": StrategyTraceHandleSchema, "outputAddress": OutputAddressSchema }).strict());
-const StrategyStateInputEntrySchema: z.ZodTypeAny = z.lazy(() => z.union([InputPotentialSchema, InputResourceSchema]));
-const StrategyStateInputEntryByRoleNameSchema: z.ZodTypeAny = z.lazy(() => z.record(z.string(), StrategyStateInputEntrySchema));
-const StrategyTraceHandleSchema: z.ZodTypeAny = z.lazy(() => z.string().regex(new RegExp("^STRATEGY_TRACE-.+$")));
-const ThreadedStrategySchema: z.ZodTypeAny = z.lazy(() => z.object({ "handle": StrategyHandleSchema, "strategyKind": z.intersection(StrategyKindSchema, z.literal("threaded")), "stepsByThreadIndex": StepArrayArraySchema, "strategyState": ThreadedStrategyStateSchema }).strict());
-const ThreadedStrategyStateSchema: z.ZodTypeAny = z.lazy(() => z.record(z.string(), StrategyStateInputEntryByRoleNameSchema).superRefine((obj, ctx) => { for (const k of Object.keys(obj)) { if (!new RegExp("^/threads/[0-9]+/steps/[0-9]+/(self|case/when|case/what|cases/[0-9]+/when|cases/[0-9]+/what)$").test(k)) ctx.addIssue({ code: 'custom', message: 'Invalid key: ' + k }); } }));
-const ThreadedStrategyStateFacetSchema: z.ZodTypeAny = z.lazy(() => z.object({ "strategyState": ThreadedStrategyStateSchema }));
-const ThreadedToolStepPathSchema: z.ZodTypeAny = z.lazy(() => z.string().regex(new RegExp("^/threads/[0-9]+/steps/[0-9]+/(self|case/when|case/what|cases/[0-9]+/when|cases/[0-9]+/what)$")));
-const ToolHandleSchema: z.ZodTypeAny = z.lazy(() => z.string().regex(new RegExp("^TOOL-.+$")));
-const ToolStepSchema: z.ZodTypeAny = z.lazy(() => z.object({ "stepKind": z.intersection(z.literal("tool"), StepKindSchema), "toolHandle": ToolHandleSchema, "roleBindingSpec": RoleBindingSpecSchema }));
-const ToolStepPathSchema: z.ZodTypeAny = z.lazy(() => z.union([UnthreadedToolStepPathSchema, ThreadedToolStepPathSchema]));
-const UnthreadedStrategySchema: z.ZodTypeAny = z.lazy(() => z.object({ "handle": StrategyHandleSchema, "strategyKind": z.intersection(StrategyKindSchema, z.literal("unthreaded")), "steps": StepArraySchema, "strategyState": UnthreadedStrategyStateSchema }).strict());
-const UnthreadedStrategyStateSchema: z.ZodTypeAny = z.lazy(() => z.record(z.string(), StrategyStateInputEntryByRoleNameSchema).superRefine((obj, ctx) => { for (const k of Object.keys(obj)) { if (!new RegExp("^/steps/[0-9]+/(self|case/when|case/what|cases/[0-9]+/when|cases/[0-9]+/what)$").test(k)) ctx.addIssue({ code: 'custom', message: 'Invalid key: ' + k }); } }));
-const UnthreadedStrategyStateFacetSchema: z.ZodTypeAny = z.lazy(() => z.object({ "strategyState": UnthreadedStrategyStateSchema }));
-const UnthreadedToolStepPathSchema: z.ZodTypeAny = z.lazy(() => z.string().regex(new RegExp("^/steps/[0-9]+/(self|case/when|case/what|cases/[0-9]+/when|cases/[0-9]+/what)$")));
-const WhileStepSchema: z.ZodTypeAny = z.lazy(() => z.object({ "stepKind": z.intersection(z.literal("while"), StepKindSchema), "case": CaseSchema }));
-
-export const StrategySchema: z.ZodTypeAny = z.lazy(() => z.union([UnthreadedStrategySchema, ThreadedStrategySchema]));