@toolproof-core/genesis 1.0.53 → 1.0.54

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

@@ -0,0 +1,533 @@
+{
+    "$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/dist/generated-src/schemas/zod/Boolean.d.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod/v4';
+export declare const BooleanSchema: z.ZodTypeAny;

package/{generated-src/schemas/zod/Boolean.ts → dist/generated-src/schemas/zod/Boolean.js}

@@ -1,6 +1,3 @@
 // Auto-generated from standalone schema 'Boolean'. Do not edit.
 import { z } from 'zod/v4';
-
-
-
-export const BooleanSchema: z.ZodTypeAny = z.lazy(() => z.boolean());
+export const BooleanSchema = z.lazy(() => z.boolean());

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

@@ -0,0 +1,2 @@
+import { z } from 'zod/v4';
+export declare const ErrorSchema: z.ZodTypeAny;

package/dist/generated-src/schemas/zod/Error.js

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

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

@@ -0,0 +1,2 @@
+import { z } from 'zod/v4';
+export declare const GoalSchema: z.ZodTypeAny;

package/dist/generated-src/schemas/zod/Goal.js

@@ -0,0 +1,5 @@
+// Auto-generated from standalone schema 'Goal'. Do not edit.
+import { z } from 'zod/v4';
+const GoalHandleSchema = z.lazy(() => z.string().regex(new RegExp("^GOAL-.+$")));
+const ToolHandleSchema = z.lazy(() => z.string().regex(new RegExp("^TOOL-.+$")));
+export const GoalSchema = 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/dist/generated-src/schemas/zod/Natural.d.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod/v4';
+export declare const NaturalSchema: z.ZodTypeAny;

package/{generated-src/schemas/zod/Natural.ts → dist/generated-src/schemas/zod/Natural.js}

@@ -1,6 +1,3 @@
 // Auto-generated from standalone schema 'Natural'. Do not edit.
 import { z } from 'zod/v4';
-
-
-
-export const NaturalSchema: z.ZodTypeAny = z.lazy(() => z.number().int().min(0));
+export const NaturalSchema = z.lazy(() => z.number().int().min(0));

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

@@ -0,0 +1,2 @@
+import { z } from 'zod/v4';
+export declare const ResourceSchema: z.ZodTypeAny;

package/dist/generated-src/schemas/zod/Resource.js

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

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

@@ -0,0 +1,2 @@
+import { z } from 'zod/v4';
+export declare const ResourceTypeSchema: z.ZodTypeAny;

package/dist/generated-src/schemas/zod/ResourceType.js

@@ -0,0 +1,11 @@
+// Auto-generated from standalone schema 'ResourceType'. Do not edit.
+import { z } from 'zod/v4';
+const DescriptionSchema = z.lazy(() => z.string().min(1));
+const DescriptionFacetSchema = z.lazy(() => z.object({ "description": DescriptionSchema }));
+const DocumentationSpecSchema = z.lazy(() => z.object({ "name": NameSchema, "symbol": z.string().optional(), "description": DescriptionSchema }));
+const JsonSchemaObjectSchema = z.lazy(() => z.object({ "$schema": z.literal("https://json-schema.org/draft/2020-12/schema") }).passthrough());
+const NameSchema = z.lazy(() => z.string().min(1).regex(new RegExp("^[A-Z][a-zA-Z0-9]*$")));
+const NameFacetSchema = z.lazy(() => z.object({ "name": NameSchema }));
+const ResourceTypeHandleSchema = z.lazy(() => z.string().regex(new RegExp("^TYPE-.+$")));
+const ToolHandleSchema = z.lazy(() => z.string().regex(new RegExp("^TOOL-.+$")));
+export const ResourceTypeSchema = 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/dist/generated-src/schemas/zod/Strategy.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod/v4';
+export declare const StrategyZodGenerationWarnings: readonly [{
+    readonly path: "$defs.StepArray.uniqueItems";
+    readonly message: "uniqueItems not enforced by generated Zod.";
+}, {
+    readonly path: "$defs.StrategyStateInputEntryByRoleName.propertyNames";
+    readonly message: "Unsupported propertyNames $ref target; keys will not be validated.";
+}, {
+    readonly path: "$defs.BranchStep.allOfMerged.properties.cases.uniqueItems";
+    readonly message: "uniqueItems not enforced by generated Zod.";
+}];
+export declare const StrategySchema: z.ZodTypeAny;