[guybedford]

This makes the Wasm ABI template a formal, versioned format, so language bindings generators can live outside ts-gen. It moves the Zena generator out onto that format alone, and adds a Kotlin/Wasm worker whose generator is written in Kotlin.

--target wat already wrote the ABI as a WAT import template, but a generator could only consume the ABI through ts-gen's Rust model. That meant every language target had to live in this repository. The template now carries the whole model as (@abi.*) annotations. These are the WebAssembly annotations proposal syntax, so any WAT tool still assembles the file, and a generator in any language can read it with a small S-expression reader.

(@abi.class "Request" (extends "Body"))
(import "./bindings.wasm" "Request.url"
  (func $Request.url (@abi.get "url") (@abi.owner "Request")
    (@abi.ts "readonly url: string")
    (param $this externref (@abi.ref "Request"))
    (result externref (@abi.ref string))))

• ABI.md specifies the format. It covers:
  • the version
  • owner records, with kind, module, aliases, extends and docs
  • one operation per import: get, set, call, new and the sys operations
  • reference heads and empties, aliases, variadics and handlers
  • a grammar of the forms used
• The ts-gen-abi crate holds the model, the writer and a reader, and has no dependencies. Every fixture template, workers-types included, reads back and rewrites byte for byte. The snapshot test checks this on every run.
• Owner references in heads and extends are absolute: "Path" for a global owner, "Path" (module "spec") for a module's. Previously a head inside declare module resolved to the module's owner of that path first. That made a module unable to reference a global owner its own owner shadows. This changes heads in the ambient-module-merge, constructor-vars and member-scopes fixtures.
• Owner records now carry extends, since inherited members are not repeated on derived owners and a generator needs to follow them.
• ts-gen embed --abi <template> builds from a template without the .d.ts.
  • --bindings-module <name> links only ABI-named imports of that module and leaves the rest to the host. Kotlin's @JsFun imports all come from js_code.
  • --imported-string-constants <name> sets the string-constants module the bindings use.
  • Validation accepts legacy exception handling, which Kotlin emits by default.
• A JsValue.undefined sys function gives modules an undefined value.
• The Zena generator moves to generators/zena as ts-gen-zena, a CLI and crate that depends only on ts-gen-abi. --target zena is removed. It reproduces all Zena snapshots from the templates alone, apart from the head fixes above.
• examples/kotlin-worker is a Kotlin/Wasm worker.
  • Its generator is Kotlin/JVM with its own reader, and has no dependency on ts-gen.
  • It emits @JsFun externals named so their imports are the ABI's names, typed owner interfaces over them, and a @JsExport entry for each handler.
  • run.sh serve builds it through embed --abi --bindings-module js_code and serves it in workerd.
  • check-templates.sh generates and compiles bindings for every fixture template.

Tests cover the format round trip, reader rejections, absolute owner references, embedding from a template, bindings-module linking and legacy exceptions. The Zena compile and worker tests need a Zena CLI with value imports, so they run only when ZENA is set and were not run for this change. The Kotlin example is not in CI because it needs a JDK and Gradle.

Open questions surfaced by the Kotlin generator:

• Function results that are Promise<T> carry only the Promise head, so a generator cannot type what they resolve to. Type arguments on heads, such as (@abi.ref "Promise" (of string)), would fix that for Promise and other generics.
• Kotlin turns every undefined an external returns into null, and cannot pass undefined either. A position that admits undefined but not null could have embed map a Wasm null to undefined.
• A module class collapsed from a global constructor var still types its new result as the module class, while its statics now return the global interface, as in TypeScript.