ritsu v0.41.0

ritsu 0.41.0

The commands that write code now work one way, and most of what follows changes how you run them: see "Changes that can make a run that used to pass fail" below for every run that stops, and what to write instead.

Generating writes only what is named

Every command that writes code — rulec gen, koyomi gen, chobo gen, dandori gen, sekisho gen, sakai gen and ritsu gen — takes --target as many times as you need and writes those targets and nothing else, so a new release that adds a target no longer makes an unchanged gen --check fail. Each target gets its library, the code other code reads; what rulec and koyomi write beside it (the runners rulec test drives, the MCP servers and their pages, the Connect service, the rounding tests, the proof harnesses, the vectors) is written only when --extra asks for it. With no --target, nothing is written: the command stops at 2 and names the arguments that write what 0.40.0 wrote. chobo build, dandori build and sakai build are now gen, and dandori's target temporal is now temporal-typescript. A ritsu.mod can say target typescript go, and ritsu gen reads it.

A name a target cannot keep

koyomi, chobo, sekisho, dandori and kaname now do the same with a name you wrote that a target's code cannot keep: check warns and names the targets, gen of those targets stops and writes nothing, the others are written, and no generator picks another name for it.

• koyomi and chobo now warn when a target spells two of the names you wrote as one identifier, or cannot take a name as it is, and stop generating that target. In the Go code koyomi writes, the dates net_30 and net30 are both Net30, a date date_ is the Date the code declares itself, and a file named go_to_ is the package goto; PostgreSQL keeps the first 63 bytes of a name, so two long aliases that agree that far are one function; rustc warns of an alias with two _ in a row (ship__by), which stops the Rust and Wasm code built with -D warnings; and a file named abc is the Python module abc, which meets the standard library's: Python loads only one of the two. In chobo's clients, the accounts stock and Stock are one method in Go, the transfers take_back and takeBack one type in Rust, and the parameters class and class_ one argument in Python; a book named return or abc is a Python module no import reaches; a parameter named __proto__ is lost in the object a TypeScript call passes; a transfer named balance or expire is a name the client uses itself; and in PostgreSQL's SQL, the balance of the account order_hold and the hold of the transfer balance_order are one function. koyomi check and chobo check passed them, and the code did not build, did not load, or answered otherwise. They now warn (koyomi's W001, chobo's W108), naming the targets, the identifier each writes and why; another name settles it (in koyomi, another alias). koyomi gen stops for a target the warning names (E016), and so does chobo gen (E064); ritsu gen stops with them, except for a Python module name, which a package holds under its own name.
• chobo's clients no longer rename a name. A name that came out the same as another one, or as the client's own balance or expire, got _2 (Stock_2, balance_2) in some languages and not in others. Every client now calls a transfer, an account and a parameter by the name the book gives it, and chobo api says those names.
• The Go client of a book named main is no longer the package main: like a book named with a keyword, it takes the file's name.
• When chobo gen stops, its last line counts the warnings of the check as well (1 error(s), 1 warning(s)).
• sekisho and dandori no longer rename a name. sekisho's code gave the second of two names that came out the same a _2 (Store_2, Date_2, RefundOrderInput_2), and dandori's a _ or Rpc (SendMail_, Transport_, Array_, str_, sendRpc), so the name a caller read was not the name you wrote, and differed by language. Now check warns and names the targets (sekisho's W402, dandori's W105), gen stops for them (E401, E051), and every other target is written as before.
• dandori's Go package leaves the nouns of a business to you. The generated package's Outcome, History, Answer and Status are now CallOutcome, RunHistory, AnswerCallback and RunStatus, since Go has one namespace for types and functions. enum Outcome, enum Status, record Answer and record History are written under the names you gave them, for --target temporal-go too.
• dandori stops only for the names the generated code reads. A type, a task or a message named print, format, filter, open, Date, Error or Map is written as it is, and a variable format keeps its name in the Python. The tables are held to the code of every flow of the tree: they gained what the code read and they lacked (ValueError, TimeoutError, RuntimeError, BaseException; Record in TypeScript).
• koyomi no longer stops every target for a name only one target breaks on. koyomi_error and parse_date break only the Go code, and a file named datetime only the Python; they are now W001 and E016 for that target. A name no target breaks on passes (a date named frozenset, a file named std, is_open in a file with no calendar).
• Files given together are compared. Two koyomi files that are one Go package, one WIT package or one PostgreSQL schema, and two chobo books that are one Go package, give a warning on the later file, which names the earlier (W001, W108). A koyomi gen of such a target stops (E016).
• More forms koyomi and chobo warn of. koyomi: a file named pg_terms or information_schema, and an input named __proto__ for Wasm. chobo: a book named like a schema PostgreSQL keeps for itself, tigerbeetle for the Python client on TigerBeetle, a book's name no Python module can have (rooms², ｓｈｏｐ), and two names Rust's NFC or Python's NFKC makes one.
• chobo's E063 holds every client to its language. A name with a character the language has no identifier for (²) stops the TypeScript, Python and Go clients as it stopped the Rust one, by each language's own table.
• A service whose two methods take one message now gets Go code that compiles (dandori): type SentRPC = Sent was written twice.
• dandori's clients no longer leave out a method without a word. A start method rpc Send or a status method rpc Histories wrote nothing in the TypeScript and Python clients, because send and histories are already there and do something else, so a caller who read send to start a run got the function that sends an event. Now check warns (W105) and gen stops for temporal-typescript and temporal-python (E051), as it already did for temporal-go. A method that does what the function does (rpc Start as the start method, rpc Status as the status method) is that function, and nothing is said.
• dandori counts the names a package declares only for the flows that declare them. A flow that runs a book's operations has BookCall, BookResult and BookTransport in its Go package, and a flow with dates has DATE in its Go package and in Python's types.py. A type of that name in such a flow passed check and stopped at go vet (DATE redeclared in this block) or mypy --strict. Now it is W105, and E051 for those targets. The same names in a flow without books or dates are written as they are.
• On Step Functions, a variable no longer hides a JSONata function. let count = …, let filter = …, let type = … and an input named type passed check and failed with States.QueryEvaluationError, the input from the first state on. A variable named as one of the 27 functions the state machine calls is now v_count, v_filter or v_type in the machine, as states already was. The keys of the input and the output stay as you wrote them, and only the definitions of flows with such a name change.
• dandori's check stops a variable the code cannot keep apart (E006). A variable that starts with dd_ can be one of the variables of the generated code (dd_error is the error on failure catches), and _x and v_x, class and class_ in Python, or type and type_ in Go are one name there. They passed check: tsc, mypy --strict or go vet stopped at the second, and on Step Functions they were one variable, whose last value both read. No caller reads a variable, so renaming one changes nothing else.

kaname generates Rust, and ritsu gen writes a package of Rust

• ritsu gen --target rust writes the package of Rust: one crate of the rules, the dates, the clients of the books and kaname's modules, in <out>/rust/, named by --name, with the crates of the clients at exactly the versions their tests run. Built for wasm32, the crate is one Wasm module that imports nothing and exports call: func(input: string) -> string; the .wit and wasm.rs come with it when the package has modules of kaname. dandori and sekisho write no Rust, so a package of Rust holds no workflow and no code of a gate: ritsu gen writes the other parts, warns on a line for each file it leaves out, and ends with 0. rust is a name of the target line of ritsu.mod too. ritsu gen --library does not write it, and stops with exit 2 and a sentence that says why.
• kaname generates Rust, as it generates TypeScript, Python and Go, and every function, type and check of the language with it: a failure comes back as a Result, a function a host calls has check_<function> for what it does not trust, and the answers are the reference interpreter's on every vector of every module.
• W001: a module named or aliased crate, self, Self, mod or door is a warning, because the generated Rust cannot take it as the name of a module. ritsu gen --target rust stops at it with E008 and writes no target, and check and the other targets take the name.
• kaname api gives the names of the Rust kaname generates, beside those of TypeScript, Python and Go: the module's file (generated.rust, glue/<module>.rs) and rust in the generated of each enum, value, record and function. Each function a host calls also has check, the names of the check a host that does not trust its input calls first ({"go": "CheckClaimFn", "rust": "check_claim"}); an inner function has null.
• kaname api has wasm: how the package's Wasm calls the module, with the exports, the keys of a call and the module that picks this module, the functions a call reaches and the shapes of what comes back (null for a module with no function a host calls).
• A name inside a function (a let, a parameter of a function given to a builtin, the value some names) that holds a character the target cannot have in a name is v in the generated TypeScript, Python and Go, with a number after it where v is taken. Before, the code kept the character and did not compile there (m², कीमत, Ⅻ).
• The TypeScript and Go kaname generates hold a date whose range has both ends written to the calendar, as they already held a date whose range leaves an end to the type: 2026-02-30 is outside >=2026-01-01 <=2026-12-31, and in TypeScript so is a string that is not a date (2026-0x-yy). Before, the entry held such a date to its ends alone, so both answered 2026-02-30 as 2026-03-02, whose day number it has, and TypeScript stopped on 2026-0x-yy with a RangeError inside the function.

rulec

• The Wasm target's module checks that the bytes it is given are UTF-8, and answers {"refused":"input","error":"the input is not UTF-8"} where they are not; before, such bytes trapped the module. Its exports are #[unsafe(no_mangle)], so the module builds on the 2024 edition too.
• The world and the package of the .wit are the rule's alias as WIT spells a name: a run of _ is one -, a _ at an end is none, and a word WIT keeps for itself takes a % (world %list). wasm-tools now reads the .wit of a rule named a__b, trailing_ or list; the names of every other rule are as they were.
• Every reader of a date on the wire takes every day of the years 0001 to 9999 as the day written, as the reference evaluator does: the runners of every language, the MCP servers and the page rulec doc draws. The year 0000 and a day the calendar does not have, such as 2026-02-30, are dates nowhere, and the page refuses them, and an empty date field, with the runner's sentence (a_due is not a date: 2026-02-30). replay, fixtures lint and diff read dates the same way.

chobo

• chobo is under the workspace's license, MIT OR Apache-2.0, again. The tables made from the Unicode Character Database, of the characters a Rust name cannot hold and of how names normalize, moved to ritsu-emit, the crate ritsu's generators share, with the name tables for Python, TypeScript and Go beside them. E063 and the Rust clients read the same table and write the same code. The license of ritsu does not change.

On the site

• Its generate view now asks for one target and shows that target's library, as gen --target <target> writes it, for rules, calendars, books, workflows and gates. A shared link says the language and the database (target=python&books=mysql), and the links 0.40.0 made (target=mysql-python, target=temporal) open the same view.

Fixed

• rulec gen, rulec vectors and rulec doc, given an --out that ends with a slash (--out generated/), said the paths with two slashes (generated//python/…). The slash at the end of --out is now dropped before a path is joined to it; the files written are the same.

Changes that can make a run that used to pass fail

Command	Up to 0.40.0	From 0.41.0	To keep it running
rulec gen	had no --target: wrote all twelve languages, the .proto and the vectors, each with every extra	stops at 2 with no --target; writes the library of each target given	name the languages with --target; the error names the command that writes what 0.40.0 wrote
	wrote the runners, the MCP servers and their pages, the Connect service, the rounding tests, the proof harnesses and the vectors	writes each only when --extra asks for it	rulec test needs --extra runner --extra vectors; the MCP server is --extra mcp, the Connect service --target python --target proto --extra connect, the rounding tests --extra round-test, the proofs --target rust --extra proof
	wrote proto/	only with --target proto	add --target proto
rulec gen --check	checked everything	needs the arguments of the line that writes, and checks only what they write	give it the same --target and --extra
rulec test	always ran the MCP step	runs the steps whose files are there; a language generated without its runner is not run, and fails --require-all	generate with --extra runner --extra vectors
MCP tool rulec_gen	took the rule files alone	needs target, an array	pass target
koyomi gen	with no --target, wrote all six targets, each with its runner; --target was given once	stops at 2 with no --target, and names the arguments that write what 0.40.0 wrote; --target may be given more than once; the runners only with --extra runner	name the targets with --target; add --extra runner where a runner reads the vectors (koyomi vectors <file.cal> | <runner>)
koyomi gen --check	with no --target, checked all six targets with their runners	stops at 2 with no --target; checks only what the same arguments write	give it the --target and --extra of the line that writes
chobo build	the verb was build	unknown command, exit 2 (`chobo build` is `chobo gen` from 0.41.0)	write chobo gen
chobo gen (was build)	--target named one pair of a database and a language (postgres, tigerbeetle-go, …)	--target sql|typescript|python|go|rust, as many as wanted, and --books postgres|tigerbeetle|mysql (default postgres); a pair stops at 2 and says its flags (`tigerbeetle-go` is `--target go --books tigerbeetle` from 0.41.0)	postgres → --target sql, mysql → --target sql --books mysql, <db>-<language> → --target <language> --books <db>
	wrote flat into --out (default .)	writes each language into <out>/<language>/, default generated (generated/sql/inventory.sql, generated/go/inventory/book.go)	add <language>/ to the paths you read, or move --out up one; delete what the old layout left, which gen leaves where it is
chobo's stop lines	said the sentence alone (unknown command `frob`)	say it after error: (エラー: with --lang ja); the exit code is 2 as before	a reader of such a line allows for the head
chobo help <command>	printed the top help and exited 0, whatever followed	prints that command's help, as chobo <command> --help does; chobo help build says what chobo build says, and a word that is no command stops at 2 as chobo <word> does	read the top help with chobo help
dandori build	the verb was build	unknown command, exit 2 (`dandori build` is `dandori gen` from 0.41.0)	write dandori gen
dandori gen --target temporal, dandori run --target temporal, ritsu run --target temporal	temporal	unknown name, exit 2 (`temporal` is `temporal-typescript` from 0.41.0); ritsu run --format json says the name given in target	write temporal-typescript; a reader of ritsu run's JSON that looks for "target": "temporal" looks for the new name
dandori gen (was build)	--target once; wrote flat into --out (default out)	--target as many times as wanted, each platform into <out>/<target>/, default generated (generated/asl/hotel_stay.asl.json, generated/temporal-typescript/hotel_stay/workflow.ts)	add <target>/ to the paths you read, or move --out up one; delete what the old layout left, which gen leaves where it is
sakai build	the verb was build	unknown command, exit 2 (`sakai build` is `sakai gen` from 0.41.0)	write sakai gen
sakai gen --check (was build --check)	the first two lines of the settings said sakai build --target <tool> and sakai build --check	they say sakai gen --target <tool> and sakai gen --target <tool> --check (with --lang ja in Japanese); on settings 0.40.0 wrote, --check stops at an E502 on the first line	write the settings once more with sakai gen --target <tool> and the same --lang, and commit them
ritsu gen	with no --target, wrote the packages of TypeScript, Python and Go	stops at 2 with neither --target nor a target line in the module's ritsu.mod, and names the command that writes what 0.40.0 wrote (ritsu gen --target typescript --target python --target go, with --target cedar where 0.40.0 wrote the Cedar)	name the targets with --target, or write target typescript python go in the module's ritsu.mod
	with a gate, or with <out>/cedar/ there, wrote <out>/cedar/ whatever --target said	writes <out>/cedar/ only with --target cedar (or cedar on the target line); without it, says what is in <out>/cedar/ and leaves it as it is (the two JSON files --target cedar writes, .cedarschema.json and .policies.json, have no head to tell them by, and are not listed)	add --target cedar
ritsu gen --check	with no --target, checked the three packages, and the Cedar as above	stops at 2 as ritsu gen does; checks only what the same arguments write	give it the arguments of the line that writes, or write the target line
ritsu gen --library	with no --target, wrote a library for each language with a library line	stops at 2 with neither --target nor a target line, and names --target of each language with a library line; a library line names a package, and a language written with no library line stops at 2	name the languages with --target, or write them on the target line
ritsu gen --format json	error had code and message; targets named the languages only	error has instead too when it stops for want of a target (the words of the command it names); targets names cedar when it is given	a reader that refuses unknown keys takes instead, and reads cedar in targets
ritsu.mod	—	has a target statement, which ritsu 0.40.0 calls E301	a module with the line asks for ritsu >=0.41.0; 0.40.0 then says it needs a newer ritsu

dandori's generated code says the commands of 0.41.0 in its comments (rulec gen <rule> --target typescript --out rulec, koyomi gen <file.cal> --target python --out …, chobo gen --target python). The build ID of a Temporal worker (BUILD_ID in worker.ts and worker.py, BuildID in worker.go) is a hash of the code, so a workflow whose code has such a comment, one that calls rules, dates or books, gets a new build ID when it is generated again; with Worker Deployment Versioning, it is a new version. Nothing else in what gen writes differs from what build wrote. The clients chobo writes and the SQL of the MySQL family say the commands of 0.41.0 in their comments too (chobo gen --target sql, chobo gen --target sql --books mysql), in the packages of ritsu gen as well.

sekisho gen only takes --target more than once now; what ran before runs the same. sakai gen takes --target once for each tool too, and writes each tool's settings where that tool looks for them, or all of them into --out; when one cannot be written (E501), it writes none. Apart from their first two lines, the settings are what sakai build wrote. ritsu gen, too, makes every target it is given before it writes any: when one cannot be made, it writes none of them, touches nothing an earlier run wrote, and its --format json names no file. 0.40.0 had written the targets before the one that stopped it, and its text did not list them (a run that stopped at Go left the TypeScript and the Python written). The help of every command shows a flag that may be given more than once with ..., rulec's --fill <field=value>... among them.

• koyomi gen (and ritsu gen) stops with E016, writing nothing, when a target it is to write is one a W001 names, where 0.40.0 wrote code that did not build, did not load, or answered for one date with another; generating the targets the warning does not name with --target writes what 0.40.0 wrote. chobo gen (and ritsu gen) stops with E064 for a target W108 names, where 0.40.0 wrote code with _2 names, code that did not build or load, or SQL that answered a call with another function. Rename one of the names the warning gives. The names of chobo's clients are the book's: where 0.40.0 wrote _2, a caller that used it calls the book's name now; the TigerBeetle clients' transfer expire was expire_2 and is expire; chobo api and the facts of a book (BookFacts) say the book's names. A book named main makes its Go package after the file's name. A run that treats warnings as failures (reading severity in koyomi check --format json or chobo check --format json, say) can stop at the new W001 and W108. No .cal or .book of ritsu's own tree, examples included, has either, and what the tree generates is unchanged.
• sekisho gen stops with E401 for a target W402 names, and dandori gen with E051 for a target W105 names, writing nothing, as ritsu gen does, where they wrote code under other names than yours. Rename what the warning names, and what reads the code with it; a target the warning does not name is written as before. In dandori this includes names Go's generated package has, such as Transport, Where and Start, builtins the Python reads, such as str and ValueError, and global types types.ts reads, such as Array and Record. Go code that reads a generated temporal-go package rewrites four names: Answer(ctx, c, id, a) is now AnswerCallback(ctx, c, id, a), Status(ctx, c, id) is RunStatus(ctx, c, id), the Outcome a Transport's Lambda and AWS return is CallOutcome, and the History that Histories gives and Replay takes is RunHistory. A flow's own type that came out as Outcome_ or Answer_ is now Outcome or Answer. What goes over the wire does not change, and the histories of earlier runs replay; as with any new code, the worker's build ID changes. koyomi gen stops with E016 for a file named pg_* or information_schema (SQL), for an input __proto__ (Wasm, which answered a host that sends the JSON with the key written), and for two files given together that are one WIT package or one PostgreSQL schema. chobo gen stops with E063 or E064 on the same forms, where it wrote code that did not build or load, and ritsu check warns of two books that are one Go package (every book with a Japanese name is the package book).
• gen also stops now for a start method rpc Send or a status method rpc Histories on temporal-typescript and temporal-python, which it wrote before without the method: rename the method, and change its callers with it, since its name is also its path on Connect. It stops for a type DATE in a flow with dates on temporal-python and pydantic-graph, whose code could not check a date (T.DATE.match). BookCall, BookResult, BookTransport and DATE on temporal-go did not compile before, so nothing that worked stops there.
• dandori check stops with E006 for a variable that starts with dd_, and for two variables that are one name in some target's code, whichever targets you write: rename the variable.
• ritsu gen --check finds stale the TypeScript and Go of a module with a date whose range has both ends written (a parameter, an element of a list or a field of a record): the line of the entry that checks it changes, and nothing else does. A host that gave such a module a day of no calendar is told it is outside the range.

Changes to the answer for the same input

• The TypeScript and JavaScript runners and MCP servers answer for a date of the years 0001 to 0099, which they refused as not a date (Date.UTC took such a year for one of the 1900s).
• The Go runner reads a date before 1677-09-22 or after 2262-04-11 as the day written. Before, it read every such day as 1677-09-22 or 2262-04-11, the ends of a time.Duration, and answered for that day.
• The Ruby runner reads a date before 1582-10-15 in the Gregorian calendar, as every other language does. Before, it read it in the Julian calendar: it gave 0001-01-01 back as 0000-12-30, answered 1500-02-29 and refused 1582-10-10.
• The page of rulec doc reads the years 0001 to 0099 as written, not as the 1900s, and refuses a day the calendar does not have, which it took for a day of the next month, and an empty date field, where it stopped.
• The year 0000 is no date anywhere. The reference evaluator, the runners of Rust, Swift, Java, Wasm, TypeScript, JavaScript, Go and Ruby, the MCP servers of TypeScript and JavaScript, the page and the functions that read a date for from refuse it, as Python, NumPy, PHP and SQL already did. Before, they answered for it.
• replay and diff leave out of the comparison a record with a day the calendar does not have, the year 0000 or a string of another shape, as a record of no shape, and fixtures lint says so and exits 1. Before, they read it as a day of the next month or of the year 0000.

Code that an earlier version generated

• rulec gen --check finds stale what an earlier version wrote of wasm/<alias>_wasm.rs, the runners of TypeScript, JavaScript, Go, Ruby, Rust, Swift and Java, the MCP servers of TypeScript and JavaScript, the pages, the modules of Python, TypeScript, JavaScript and Ruby of a rule that reads a date with from, and the .wit of a rule whose world changes above; run rulec gen again.

ritsu 0.41.0（日本語）

コードを書くコマンドの使い方を一つにそろえました。下の多くは、コマンドの動かし方を変えるものです。止まるようになる実行と書き換え方は、全部を「前は通っていた実行が落ちうる変更」の節に挙げました。

生成は、指定したものだけを書く

コードを書くコマンド（rulec gen、koyomi gen、chobo gen、dandori gen、sekisho gen、sakai gen、ritsu gen）は、どれも --target を何度でも書けて、指定した出力先だけを書きます。出力先を足したリリースのあとでも、変えていない規則の gen --check は落ちません。出力先ごとに書くのは、ほかのコードが読むライブラリです。rulec と koyomi がその横に書く付属物（rulec test が走らせるランナー、MCP のサーバーとそのページ、Connect のサービス、丸めの試験、証明のハーネス、ベクタ）は、--extra で頼んだときだけ書きます。--target を付けなければ何も書かず、2 で終わり、0.40.0 が書いたものと同じものを書く引数を示します。chobo build・dandori build・sakai build は gen になり、dandori の出力先 temporal は temporal-typescript になりました。ritsu.mod に target typescript go と書けば、ritsu gen がそれを読みます。

出力先のコードが持てない名前

koyomi、chobo、sekisho、dandori、kaname は、書いた名前を出力先のコードが持てないとき、同じことをするようになりました。check が出力先を挙げて警告し、その出力先の gen は止まって何も書かず、ほかの出力先は書きます。どの生成器も、別の名前に付け替えません。

• 書いた二つの名前が出力先の綴りで一つの識別子になるとき、また出力先が名前をそのままでは使えないとき、koyomi と chobo の check が警告し、その出力先の生成が止まるようになりました。 koyomi が書く Go のコードでは、日付 net_30 と net30 はどちらも Net30、日付 date_ はコードが自分で宣言する Date、別名 go_to_ のファイルはパッケージ goto です。PostgreSQL は名前の先頭の 63 バイトだけを残すので、そこまで同じ二つの長い別名は一つの関数になります。_ が二つ続く別名（ship__by）は rustc が警告し、-D warnings でビルドする Rust と Wasm のコードが止まります。別名 abc のファイルは Python のモジュール abc になり、標準ライブラリの abc とぶつかります（Python は二つのうち一つしか読み込みません）。chobo のクライアントでは、勘定 stock と Stock は Go で一つのメソッドに、振替 take_back と takeBack は Rust で一つの型に、引数 class と class_ は Python で一つの引数になります。名前が return や abc の帳簿は import で読み込めない Python のモジュールになり、__proto__ という名前の引数は TypeScript の呼び出しが渡すオブジェクトから落ち、振替 balance と expire はクライアントが自分で使う名前に当たります。PostgreSQL の SQL では、勘定 order_hold の残高と振替 balance_order の仮押さえが一つの関数になります。koyomi check と chobo check はこうしたファイルを通し、生成したコードはビルドできないか、読み込めないか、答えが違っていました。いまは、どの出力先で何という識別子になるかと理由を警告し（koyomi の W001、chobo の W108）、名前（koyomi では別名）を変えれば警告は消えます。警告が挙げる出力先を書く koyomi gen は E016 で、chobo gen は E064 で止まります。ritsu gen も止まります。ただし、パッケージが自分の名前の下に置く Python のモジュールの名前の形では止まりません。
• chobo のクライアントが名前を付け替えなくなりました。 これまでは、ほかの名前やクライアントの balance・expire と同じになる名前に、言語によって _2 を付けていました（Stock_2、balance_2）。いまは、どの言語のクライアントも、振替、勘定、引数を帳簿の名前で呼び、chobo api もその名前を言います。
• 名前が main の帳簿の Go のクライアントが、パッケージ main にならなくなりました。 名前がキーワードの帳簿と同じく、ファイルの名前を使います。
• chobo gen が止まったときの最後の行が、検査の警告の数も言うようになりました（エラー 1 件、警告 1 件）。
• sekisho と dandori の生成器が、名前を付け替えなくなりました。 sekisho は同じになる名前の二つ目に _2 を（Store_2、Date_2、RefundOrderInput_2）、dandori は _ や Rpc を（SendMail_、Transport_、Array_、str_、sendRpc）足していたので、呼ぶ側が読む名前が書いた名前と違い、言語によっても違いました。いまは check が出力先を挙げて警告し（sekisho の W402、dandori の W105）、その出力先の gen が止まり（E401、E051）、ほかの出力先はこれまでどおり書きます。
• dandori の Go のパッケージが、業務でよく使う名前を使わなくなりました。 生成するパッケージの Outcome、History、Answer、Status を CallOutcome、RunHistory、AnswerCallback、RunStatus にしました。Go は型と関数が一つの名前空間だからです。enum Outcome、enum Status、record Answer、record History は、--target temporal-go でも書いた名前のままになります。
• dandori が止めるのは、生成するコードが読む名前だけになりました。 print、format、filter、open、Date、Error、Map という名前の型、タスク、メッセージは、そのまま書きます。変数の format も、Python のコードでそのままです。表は木の全部のフローの生成物と比べます。読むのに表に無かった名前（ValueError、TimeoutError、RuntimeError、BaseException、TypeScript の Record）は足しました。
• koyomi が、一つの出力先でしか壊れない名前で全部の出力先を止めなくなりました。 koyomi_error と parse_date は Go のコードだけで、別名 datetime のファイルは Python のコードだけで壊れるので、その出力先の W001 と E016 にしました。どの出力先でも壊れない名前（日付 frozenset、ファイル std、カレンダーの無いファイルの is_open）は通ります。
• 一緒に渡したファイルを比べるようになりました。 一つの Go のパッケージ、WIT の package、PostgreSQL のスキーマになる二つの koyomi のファイルと、一つの Go のパッケージになる二冊の chobo の帳簿は、後のファイルに警告が付き、前のファイルを挙げます（W001、W108）。koyomi の gen は、その出力先で止まります（E016）。
• koyomi と chobo が警告する形が増えました。 koyomi は、別名 pg_terms と information_schema のファイルと、Wasm の入力 __proto__。chobo は、PostgreSQL が自分のものにするスキーマの名前の帳簿、TigerBeetle の Python のクライアントの帳簿 tigerbeetle、Python のモジュールにできない帳簿の名前（rooms²、ｓｈｏｐ）、Rust の NFC と Python の NFKC で同じになる二つの名前です。
• chobo の E063 が、どのクライアントも言語の表で確かめます。 言語の識別子にならない字（²）を持つ名前は、Rust のクライアントと同じように、TypeScript、Python、Go のクライアントでも止まります。
• 二つのメソッドが同じメッセージを取るサービスの Go のコードがビルドできるようになりました（dandori）。type SentRPC = Sent を二度書いていました。
• dandori のクライアントが、メソッドを黙って落とさなくなりました。 開始のメソッドの rpc Send と状態のメソッドの rpc Histories は、TypeScript と Python のクライアントで何も書かれませんでした。send と histories は別のことをする関数としてもうあるので、send で始めるつもりの呼ぶ側は、イベントを送る関数を読んでいました。いまは check が警告し（W105）、temporal-typescript と temporal-python の gen が止まります（E051）。temporal-go はこれまでも同じです。同じことをするメソッド（開始の rpc Start、状態の rpc Status）は、その関数のことなので何も言いません。
• dandori は、パッケージが宣言する名前を、それを宣言するフローのときだけ数えます。 帳簿の操作を動かすフローの Go のパッケージは BookCall、BookResult、BookTransport を、日付を持つフローの Go のパッケージと Python の types.py は DATE を宣言します。そういうフローの同じ名前の型は check を通り、go vet（DATE redeclared in this block）か mypy --strict で止まっていました。いまは W105 で、その出力先は E051 です。帳簿の操作も日付も無いフローの同じ名前は、そのまま書きます。
• Step Functions で、変数が JSONata の関数を隠さなくなりました。 let count = …、let filter = …、let type = … と入力 type は check を通り、States.QueryEvaluationError で落ちていました（入力 type は最初のステートから）。ステートマシンが呼ぶ 27 個の関数と同じ名前の変数は、states と同じに、ステートマシンの中で v_count、v_filter、v_type になります。入力と出力のキーは書いた名前のままで、定義が変わるのはその名前を持つフローだけです。
• dandori の check が、生成するコードで分けられない変数を止めるようになりました（E006）。 dd_ で始まる変数は生成するコードの変数と同じ名前になることがあります（dd_error は on failure が受けるエラーです）。_x と v_x、Python の class と class_、Go の type と type_ は、そのコードで一つの名前になります。これまでは check を通り、tsc、mypy --strict、go vet が二つ目で止まるか、Step Functions で一つの変数になって、後の値を両方が読んでいました。変数は呼ぶ側が読まないので、名前を変えてもほかには何も変わりません。

kaname が Rust を生成し、ritsu gen が Rust のパッケージを書く

• ritsu gen --target rust が Rust のパッケージを書きます。規則、日付、帳簿のクライアント、kaname のモジュールを一つのクレートにして <out>/rust/ に置きます。クレートの名前は --name で指定し、クライアントのクレートへの依存は試験で使う版に固定します。wasm32 向けにビルドすると、何も import せず call: func(input: string) -> string を export する一つの Wasm モジュールになります。kaname のモジュールがあれば .wit と wasm.rs も書きます。dandori と sekisho は Rust を書かないので、ワークフローとゲートのコードは入りません。ritsu gen はそれ以外を書き、入らないファイルごとに一行警告して 0 で終わります。ritsu.mod の target の行にも rust を書けます。ritsu gen --library は Rust を書かず、理由を一文で言って 2 で終わります。
• kaname が TypeScript・Python・Go と同じく Rust を生成するようになりました。言語の関数、型、検査を全部書きます。失敗は Result で返り、ホストが呼ぶ関数には、信頼できない入力のための check_<関数> が付きます。どのモジュールのどのベクタにも、参照インタプリタと同じ答えを返します。
• W001：モジュールの名前か別名が crate、self、Self、mod、door なら、生成する Rust でモジュールの名前に使えないので警告します。ritsu gen --target rust は E008 で止まり、どの出力先も書きません。check とほかの出力先は、その名前を通します。
• kaname api が、TypeScript・Python・Go に加えて、生成する Rust の名前も返すようになりました。モジュールのファイル（generated.rust。glue/<モジュール>.rs）と、列挙、値、レコード、関数の generated の rust です。ホストが呼ぶ関数には check も付きます。入力を信頼しないホストが先に呼ぶ検査の名前で（{"go": "CheckClaimFn", "rust": "check_claim"}）、内側の関数では null です。
• kaname api に wasm が増えました。パッケージの Wasm がそのモジュールをどう呼ぶかを示すもので、export、呼び出しのキーとモジュールを選ぶ module、呼び出せる関数、返る値の形を返します（ホストが呼ぶ関数の無いモジュールは null）。
• 関数の内側の名前（let、組み込み関数に渡す関数の引数、some の名前）に出力先の言語で使えない字があるとき、生成する TypeScript・Python・Go ではその名前を v にします（v が使われていれば番号を付けます）。これまでは字をそのまま書き、コンパイルできませんでした（m²、कीमत、Ⅻ）。
• kaname が生成する TypeScript と Go は、範囲の両端を書いた日付でも、暦にある日かを確かめるようになりました（端を型に任せた日付は前から確かめています）。2026-02-30 は >=2026-01-01 <=2026-12-31 の範囲の外になり、TypeScript では日付でない文字列（2026-0x-yy）も範囲の外になります。これまでは両端とだけ比べていたので、どちらも 2026-02-30 を 2026-03-02 として答え、TypeScript は 2026-0x-yy で関数の中の RangeError で止まっていました。

rulec

• Wasm の出力先のモジュールは、受け取ったバイト列が UTF-8 かを確かめ、そうでなければ {"refused":"input","error":"the input is not UTF-8"} を返します。これまではトラップしていました。export は #[unsafe(no_mangle)] になり、エディション 2024 でもビルドできます。
• .wit の world と package の名前を、規則の別名を WIT の書き方に直したものにしました。続く _ は一つの - に、端の _ は無しにし、WIT の予約語には % を付けます（world %list）。a__b、trailing_、list という名前の規則の .wit を、wasm-tools が読めるようになりました。ほかの規則の名前は変わりません。
• JSON で受け取る日付は、どこでも参照評価器と同じく、年 0001〜9999 の日を書いたとおりの日として読みます。どの言語のランナーも、MCP のサーバーも、rulec doc のページも同じです。年 0000 と暦に無い日（2026-02-30 など）はどこでも日付ではありません。ページは、それらと空の日付の欄を、ランナーと同じ文（a_due is not a date: 2026-02-30）で拒みます。replay、fixtures lint、diff も同じように読みます。

chobo

• chobo のライセンスが、ワークスペースのもの（MIT OR Apache-2.0）に戻りました。Unicode Character Database から作った表（Rust の名前に使えない字と、名前の正規化）を、ritsu の生成器が共有するクレート ritsu-emit に移し、Python・TypeScript・Go の名前の表も同じ場所に置きました。E063 と Rust のクライアントは同じ表を読むので、書くコードも同じです。ritsu のライセンスは変わりません。

サイト

• 生成の表示は、出力先を一つ選び、gen --target <出力先> が書くライブラリを見せます（規則、暦、帳簿、ワークフロー、ゲート）。共有のリンクは言語とデータベースを言います（target=python&books=mysql）。0.40.0 が作ったリンク（target=mysql-python、target=temporal）も同じ表示を開きます。

直したこと

• rulec gen・rulec vectors・rulec doc は、--out generated/ のように --out を / で終えると、パスを generated//python/… と二重の / で言っていました。いまは --out の終わりの / を落としてからつなぎます。書くファイルは前と同じです。

前は通っていた実行が落ちうる変更

コマンド	0.40.0 まで	0.41.0 から	書き換え方
rulec gen	--target が無く、12 の言語と .proto とベクタを、付属物つきで全部書いた	--target が無ければ exit 2。指定した出力先のライブラリだけを書く	使う言語を --target で書く。0.40.0 と同じものは、止まったときの文が示すコマンド
	ランナー、MCP のサーバーとページ、Connect のサービス、丸めの試験、証明のハーネス、ベクタを書いた	--extra で頼んだときだけ	rulec test には --extra runner --extra vectors。MCP は --extra mcp、Connect は --target python --target proto --extra connect、丸めの試験は --extra round-test、証明は --target rust --extra proof
	proto/ を書いた	--target proto のときだけ	--target proto を足す
rulec gen --check	全部を確かめた	書くときの引数が要り、それが書くものだけを確かめる	書くときと同じ --target と --extra を付ける
rulec test	MCP の段はいつも走った	ファイルのある段だけ。ランナー抜きで生成した言語は走らず、--require-all で落ちる	--extra runner --extra vectors を付けて生成する
rulec の MCP の rulec_gen	規則のファイルだけでよかった	target（配列）が要る	target を渡す
koyomi gen	--target が無ければ六つの出力先を全部、どれもランナーつきで書いた。--target は一つだけ	--target が無ければ exit 2 で、0.40.0 と同じものを書く引数を示す。--target は何度でも書け、ランナーは --extra runner のときだけ	出力先を --target で書く。ランナーでベクタを読むところ（koyomi vectors <file.cal> | <ランナー>）には --extra runner を足す
koyomi gen --check	--target が無ければ六つの出力先をランナーつきで確かめた	--target が無ければ exit 2。同じ引数が書くものだけを確かめる	書くときと同じ --target と --extra を付ける
chobo build	動詞は build	知らないコマンドとして exit 2（ `chobo build` は 0.41.0 から `chobo gen` です）	chobo gen と書く
chobo gen（前の build）	--target に、データベースと言語の組の名前（postgres、tigerbeetle-go など）を一つ	--target sql|typescript|python|go|rust を何度でもと、--books postgres|tigerbeetle|mysql（既定 postgres）。組の名前は 2 で止まり、それに当たるフラグを言う（ `tigerbeetle-go` は 0.41.0 から `--target go --books tigerbeetle` です）	postgres → --target sql、mysql → --target sql --books mysql、<db>-<言語> → --target <言語> --books <db>
	--out（既定 .）に平らに書いた	言語ごとに <out>/<言語>/、既定 generated（generated/sql/inventory.sql、generated/go/inventory/book.go）	読むパスに <言語>/ を足すか、--out を一つ上にする。前の置き方で書いたファイルは gen が消さずに残すので、消す
chobo の止まる文	文だけを言った（unknown command `frob`）	同じ文の前に error: （--lang ja では エラー: ）が付く。終了コードは前と同じ 2	その行を読むコードは、この error: を見込む
chobo help <コマンド>	何を続けてもトップの help を出し、0 で終わった	そのコマンドの help を出す（chobo <コマンド> --help と同じ）。chobo help build は chobo build と同じ文を言い、コマンドでない語は chobo <語> と同じく 2 で止まる	トップの help は chobo help で読む
dandori build	動詞は build	知らないコマンドとして exit 2（ `dandori build` は 0.41.0 から `dandori gen` です）	dandori gen と書く
dandori gen --target temporal、dandori run --target temporal、ritsu run --target temporal	temporal	知らない名前として exit 2（ `temporal` は 0.41.0 から `temporal-typescript` です）。ritsu run --format json の target は渡した名前を言う	temporal-typescript と書く。ritsu run の JSON の "target": "temporal" を見るコードは、新しい名前を見る
dandori gen（前の build）	--target は一つだけ。--out（既定 out）に平らに書いた	--target は何度でも書け、出力先ごとに <out>/<出力先>/、既定 generated（generated/asl/hotel_stay.asl.json、generated/temporal-typescript/hotel_stay/workflow.ts）	読むパスに <出力先>/ を足すか、--out を一つ上にする。前の置き方で書いたファイルは gen が消さずに残すので、消す
sakai build	動詞は build	知らないコマンドとして exit 2（ `sakai build` は 0.41.0 から `sakai gen` です）	sakai gen と書く
sakai gen --check（前の build --check）	設定の最初の二行は sakai build --target <ツール> と sakai build --check と言った	sakai gen --target <ツール> と sakai gen --target <ツール> --check（日本語の設定は --lang ja つき）と言う。0.40.0 が書いた設定では、--check が一行目の E502 で止まる	一度 sakai gen --target <ツール> に同じ --lang を付けて書き直し、コミットする
ritsu gen	--target が無ければ、TypeScript・Python・Go のパッケージを書いた	--target もモジュールの ritsu.mod の target の行も無ければ exit 2 で、0.40.0 と同じものを書くコマンドを示す（ritsu gen --target typescript --target python --target go。0.40.0 が Cedar を書いたところでは --target cedar も）	--target を書くか、モジュールの ritsu.mod に target typescript python go の行を書く
	ゲートがあるか <out>/cedar/ があれば、--target に関わらず <out>/cedar/ を書いた	--target cedar（か target の行の cedar）のときだけ書く。無ければ、<out>/cedar/ にあるものを挙げ、そのまま残す（--target cedar が書く二つの JSON、.cedarschema.json と .policies.json は、先頭のコメントが無いので挙げない）	--target cedar を足す
ritsu gen --check	--target が無ければ、三つのパッケージと、上のとおり Cedar を確かめた	ritsu gen と同じく exit 2。同じ引数が書くものだけを確かめる	書くときと同じ引数を付けるか、target の行を書く
ritsu gen --library	--target が無ければ、library の行のある言語ごとにライブラリを書いた	--target も target の行も無ければ exit 2 で、library の行の言語ごとの --target を示す。library の行はパッケージの名前を与え、行の無い言語を書けば exit 2	言語を --target で書くか、target の行に書く
ritsu gen --format json	error は code と message。targets は言語だけ	出力先が無くて止まったときは、error に instead（示したコマンドの語）も付く。targets は、指定したときは cedar も言う	知らないキーを受け付けないコードは instead を受け付け、targets の cedar を読む
ritsu.mod	—	target の文が増える。0.40.0 の ritsu はその行を E301 にする	行を書くモジュールは ritsu >=0.41.0 も書く。0.40.0 は、新しい ritsu が要ると言って止まる

dandori が生成したコードのコメントは、0.41.0 のコマンドを言います（rulec gen <rule> --target typescript --out rulec、koyomi gen <file.cal> --target python --out …、chobo gen --target python）。Temporal のワーカーのビルドの ID（worker.ts と worker.py の BUILD_ID、worker.go の BuildID）はコードのハッシュなので、このコメントを持つワークフロー（規則、日付、帳簿を呼ぶもの）は、生成し直すとビルドの ID が変わり、Worker Deployment Versioning では新しい版になります。gen が書くもので build と違うのは、ほかにありません。chobo が書くクライアントと MySQL の系統の SQL も、コメントで 0.41.0 のコマンドを言います（chobo gen --target sql、chobo gen --target sql --books mysql）。ritsu gen のパッケージの中でも同じです。

sekisho gen は、--target を何度でも書けるようになっただけで、前に通っていた実行はそのまま通ります。sakai gen も、--target をツールごとに一つずつ書けます。どの設定もそのツールが探すところに（--out があればそこに）書き、どれかが書けなければ（E501）どれも書きません。設定は、最初の二行のほかは sakai build が書いたものと同じです。ritsu gen も、指定した出力先を全部作ってから書きます。一つでも作れなければ、どれも書かず、前の実行が書いたファイルにも触らず、--format json の files も空です。0.40.0 は、止まった出力先より前のものを書き、文の出力はそれを挙げませんでした（Go で止まった実行は、TypeScript と Python を書いたまま残しました）。どのコマンドの --help も、何度でも書けるフラグを ... を付けて見せます（rulec の --fill <field=value>... も）。

• 書く出力先を W001 が挙げると、koyomi gen（と ritsu gen）は E016 で止まり、何も書きません。 0.40.0 は、ビルドできないコードか、読み込めないコードか、ある日付の答えを別の日付の答えで返すコードを書いていました。警告が挙げない出力先を --target で書けば、0.40.0 と同じものを書きます。W108 が挙げる出力先の chobo gen（と ritsu gen）は E064 で止まります。 0.40.0 は、_2 を付けた名前のコードか、ビルドできないか読み込めないコードか、呼び出しに別の関数が答える SQL を書いていました。警告が挙げる名前の一つを変えてください。chobo のクライアントの名前は帳簿のとおりです。 0.40.0 が _2 を付けた名前を呼んでいたところは、帳簿の名前で呼ぶことになります。TigerBeetle のクライアントの振替 expire は expire_2 から expire になります。chobo api と帳簿の事実（BookFacts）も帳簿の名前を言います。名前が main の帳簿の Go のパッケージは、ファイルの名前になります。警告も止める使い方（koyomi check --format json や chobo check --format json の severity を見る CI など）では、新しい W001 と W108 で止まることがあります。 ritsu の木の .cal と .book（例を含む）には、どちらもなく、木から生成するものも変わりません。
• W402 が挙げる出力先の sekisho gen は E401 で、W105 が挙げる出力先の dandori gen は E051 で止まり、何も書きません（ritsu gen も同じです）。 これまでは、書いた名前と違う名前のコードを書いていました。警告が挙げる名前と、そのコードを読むところを直してください。警告が挙げない出力先は、これまでどおり書きます。dandori では、Transport、Where、Start のような Go のパッケージの名前、str、ValueError のような Python のコードが読む組み込み、Array、Record のような types.ts が読むグローバルな型も当たります。temporal-go の生成物を読む Go のコードは、四つの名前を書き換えてください。 Answer(ctx, c, id, a) は AnswerCallback(ctx, c, id, a) に、Status(ctx, c, id) は RunStatus(ctx, c, id) に、Transport の Lambda と AWS が返す Outcome は CallOutcome に、Histories が返し Replay が受ける History は RunHistory になります。Outcome_、Answer_ になっていたフローの型は、Outcome、Answer になります。通信の中身は変わらず、前の実行の履歴も再生できます。新しいコードはどれもそうですが、ワーカーのビルドの ID は変わります。koyomi gen は E016 で止まります。 別名が pg_ で始まるか information_schema のファイル（SQL）、入力 __proto__（Wasm。JSON の文字列でキーを書くホストには答えていました）、一緒に渡して一つの WIT の package か PostgreSQL のスキーマになる二つのファイルです。chobo gen は同じ形で E063 か E064 で止まります。 これまではビルドできないか読み込めないコードを書いていました。ritsu check は、一つの Go のパッケージになる二冊の帳簿を警告します（日本語の名前の帳簿は、どれもパッケージ book です）。
• gen は、temporal-typescript と temporal-python で、開始のメソッドの rpc Send と状態のメソッドの rpc Histories でも止まるようになりました。前はそのメソッドを書かずに進んでいました。メソッドの名前を変え、呼ぶ側も合わせてください。メソッドの名前は Connect のパスでもあります。temporal-python と pydantic-graph で、日付を持つフローの型 DATE でも止まります。前のコードは日付を検査できませんでした（T.DATE.match）。temporal-go の BookCall、BookResult、BookTransport、DATE は前からコンパイルできなかったので、動いていたものが止まることはありません。
• dandori check は、dd_ で始まる変数と、どれかの出力先のコードで一つの名前になる二つの変数を、どの出力先を書くときも E006 で止めます。変数の名前を変えてください。
• 範囲の両端を書いた日付（引数、リストの要素、レコードのフィールド）を持つモジュールの TypeScript と Go を、ritsu gen --check が古いと報告します。変わるのは、その日付を確かめる入口の行だけです。そういうモジュールに暦に無い日を渡していたホストには、範囲の外だと返ります。

同じ入力の答えが変わる変更

• TypeScript と JavaScript のランナーと MCP のサーバーが、年 0001〜0099 の日付に答えるようになりました。これまでは日付でないとして拒んでいました（Date.UTC がその年を 1900 年代として読むためです）。
• Go のランナーは、1677-09-22 より前と 2262-04-11 より後の日付を、書いたとおりの日として読みます。これまでは、そういう日を全部 1677-09-22 か 2262-04-11（time.Duration の端）として読み、その日の答えを返していました。
• Ruby のランナーは、1582-10-15 より前の日付を、ほかの言語と同じくグレゴリオ暦で読みます。これまではユリウス暦で読み、0001-01-01 を 0000-12-30 として返し、1500-02-29 に答え、1582-10-10 を拒んでいました。
• rulec doc のページは、年 0001〜0099 を 1900 年代ではなく書いたとおりの年として読み、暦に無い日（これまでは次の月の日として読みました）と空の日付の欄（これまではそこで止まりました）を拒みます。
• 年 0000 は、どこでも日付ではなくなりました。参照評価器、Rust・Swift・Java・Wasm・TypeScript・JavaScript・Go・Ruby のランナー、TypeScript と JavaScript の MCP のサーバー、ページ、from のために日付を読む関数は、これまで答えていましたが、いまは拒みます。Python・NumPy・PHP・SQL は前から拒んでいます。
• replay と diff は、暦に無い日、年 0000、形の違う文字列を持つ記録を、形の合わない記録として比較から外し、fixtures lint はそれを報告して 1 で終わります。これまでは次の月の日や年 0000 の日として読んでいました。

前の版が生成したコード

• 前の版が書いた wasm/<別名>_wasm.rs、TypeScript・JavaScript・Go・Ruby・Rust・Swift・Java のランナー、TypeScript と JavaScript の MCP のサーバー、ページ、from で日付を読む規則の Python・TypeScript・JavaScript・Ruby のモジュールと、上で world の変わる規則の .wit を、rulec gen --check が古いと報告します。rulec gen を実行し直してください。