Resolves a WIT type to a Go type. # Panics This function panics if: - The type definition cannot be found in the resolve context. - The type is sti

Returns a globally-unique kebab-case name suitable for deriving a Go identifier from a WIT type. WIT lets two interfaces declare types of the same nam

Analyze a type definition. Returns `None` for `Type::Id` aliases that just re-export an already-analyzed type.

Detect the WIT shorthand `case-name(case-name)` where the payload is a named record sharing the case's name — the historical arcjet shape (`allow-emai

Generate the Go function code for the given function. The signature is obtained by: - getting the function parameters from the `wit_parser::Function`

Like [`resolve_type`], but downgrades a top-level Variant to `interface{}` so existing call sites can keep passing the variant payload through `any`-t

Resolves a Wasm type to a Go type.

Kebab-case Go name for the type a variant case dispatches against in a type-switch.

Generate the `writeString` helper function.

Build parameter list for factory constructor

Returns an iterator over the characters of the underlying name. This provides access to the raw name without case transformations. # Returns An iter

Helper function to create a Go comment.

Helper function to create an embed directive.

Generate the bindings. This generates the imports (interfaces, types, functions), the factory and instance type, and the exports (functions).

Generates all exports for the world. Note: for now this only generates functions; types and interfaces are still TODO

Generate the Factory struct, constructor, and methods.

Generates the factory and instantiate functions, including any required interfaces.

Generates the imports for the bindings.

Generate the Instance struct, and methods.

Extract import chains for host module builders

Adds the given Wasm to the bindings.

The Go expression that resolves to the wasm `api.Module` in the current direction. Exports live on a Go-side instance struct (`i.module`); imports rec

TestCheckEnabled tests regression 1: import function returning bool. The Wasm guest calls the imported is-enabled function and returns the bool result

TestCheckStatus tests regression 1: import function returning enum. This is the exact pattern that was failing in Arcjet's bot bindings, where verify-

TestChooseMany exercises a variant whose payload is `list<variant>` (e.g. `allow-all(list<entity>)`). Gravity must wrap the list in a `EntitiesAllowAl

TestChoose_DirectRecordDispatch exercises the WIT shorthand `case(case)` — when a variant case's only payload is a named record sharing its name, grav

TestClassify_PayloadCase exercises lifting a payload-bearing case where the payload is a primitive — the wrapper carries it in `Value`. Regression: th

TestClassify_UnitCase exercises lifting a unit-case variant returned from the guest. The wrapper struct must be zero-sized and the type switch on the

TestCrossInterfaceEnumCollision covers regression 4. Both `email-checker` and `bot-verifier` define `enum validator-response` inside the same world; w

TestDoubleValue tests regression 2: import function with u32 parameters. Before the fix, gravity generated api.EncodeU32()/api.DecodeU32() for I32From

TestImportCallbackOptionString covers regression 5. The `ip-source` import returns `option<string>`. Lowering it into wasm memory must run against the

TestRunPing tests regression 3: import function with zero WIT parameters. The pinger.ping import takes no arguments (only the implicit ctx and mod par

TestTagAll exercises: - returning a list of records from the guest (list lift of record) - records that contain a variant field (variant lift inside r

Returns the primary value of the operand. For single values and literals, returns the value itself. For multi-value tuples, returns the first value.