chore: release v0.4.1

abi/data_hash_gen.go

@@ -0,0 +1,29 @@
+// Code generated by apigen. DO NOT EDIT.
+
+package abi
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+)
+
+// DataHash is the canonical hash of a manifest primitives block. The generated data package bakes
+// it in and an upload whose manifest does not match it is rejected, so a manifest edited without a
+// regenerate never runs against stale generated types. Key order and whitespace do not matter.
+// A module with no primitives hashes to the empty string.
+func DataHash(primitives json.RawMessage) string {
+	var decoded any
+	if err := json.Unmarshal(primitives, &decoded); err != nil || decoded == nil {
+		return ""
+	}
+
+	encoded, err := json.Marshal(decoded)
+	if err != nil || string(encoded) == "{}" {
+		return ""
+	}
+
+	sum := sha256.Sum256(encoded)
+
+	return hex.EncodeToString(sum[:])
+}

data.go

@@ -0,0 +1,403 @@
+package rudder
+
+import (
+	"encoding/json"
+	"errors"
+	"sort"
+	"time"
+
+	"hub.rudder.build/rudder/rudder-module-go/abi"
+)
+
+const (
+	OwnerKindPlayer  = "player"
+	OwnerKindProject = "project"
+
+	catalogLimit = 1000
+)
+
+type Owner = abi.Owner
+
+func Player(id string) Owner { return Owner{Kind: OwnerKindPlayer, ID: id} }
+
+func (c *Context) Owner() Owner {
+	if c.Player == nil {
+		return Owner{}
+	}
+	return Owner{Kind: OwnerKindPlayer, ID: c.Player.ID}
+}
+
+type Op struct{ Key string }
+
+func OpKey(op []Op) string {
+	if len(op) == 0 {
+		return ""
+	}
+	return op[0].Key
+}
+
+// Reward is what a designer types into a catalog row: some currencies, some items. It is granted
+// as ONE mutation, all-or-nothing: a reward that fails halfway leaves nothing behind, and one
+// idempotency key makes the whole grant idempotent.
+type Reward struct {
+	Currencies map[string]int64 `json:"currencies,omitempty"`
+	Items      map[string]int64 `json:"items,omitempty"`
+}
+
+func (r Reward) Empty() bool {
+	return len(r.Currencies) == 0 && len(r.Items) == 0
+}
+
+// Price is what a catalog field of type price carries. Without it a module hand-decodes a
+// json.RawMessage every time it reads the number a designer typed into the price form.
+type Price struct {
+	Currency string `json:"currency"`
+	Amount   int64  `json:"amount"`
+}
+
+// Version is a document's optimistic-concurrency token. Zero means the document does not exist,
+// which is what Get reads back for a miss and what Put demands for "must not exist yet".
+type Version int64
+
+type Written struct {
+	Version Version `json:"version"`
+}
+
+// Unchanged tells Patch not to write. Patch returns the document as it was, with no error.
+var Unchanged = errors.New("rudder: document unchanged")
+
+// IsCode reports whether err is a kernel business error carrying this code. Without it every
+// module writes the same errors.As block to map one kernel code onto one of its own.
+func IsCode(err error, code string) bool {
+	var failure *Error
+	return errors.As(err, &failure) && failure.Code == code
+}
+
+// JSON marshals a generated document type for a command. A type the generator emitted always
+// marshals, so a failure here is a generator bug: it traps the call rather than letting the kernel
+// store null.
+func JSON(value any) json.RawMessage {
+	body, err := json.Marshal(value)
+	if err != nil {
+		panic("rudder: generated document does not marshal: " + err.Error())
+	}
+	return body
+}
+
+// Stamp is the wire form of an optional timestamp. The ABI carries times as RFC3339 strings, and a
+// nil time has to stay nil rather than become the zero year.
+func Stamp(value *time.Time) *string {
+	if value == nil {
+		return nil
+	}
+	formatted := value.UTC().Format(time.RFC3339Nano)
+	return &formatted
+}
+
+func One[Result any](command any) (Result, error) {
+	var result Result
+	if err := call(command, &result); err != nil {
+		var zero Result
+		return zero, err
+	}
+	return result, nil
+}
+
+type Batch struct {
+	commands []json.RawMessage
+	targets  []any
+	ran      bool
+}
+
+func (b *Batch) add(command any, target any) {
+	body, err := json.Marshal(command)
+	if err != nil {
+		panic(err)
+	}
+	b.commands = append(b.commands, body)
+	b.targets = append(b.targets, target)
+}
+
+// Run sends every command in one data.exec call. The batch is all-or-nothing: the first error
+// discards every command that already applied.
+func (b *Batch) Run() error {
+	if len(b.commands) == 0 {
+		return nil
+	}
+	result, err := Data{}.Exec(abi.DataExecParameters{Commands: b.commands})
+	if err != nil {
+		return err
+	}
+	if len(result.Results) != len(b.targets) {
+		return errors.New("rudder: data.exec returned a different number of results than commands")
+	}
+	for index, raw := range result.Results {
+		if len(raw) == 0 {
+			continue
+		}
+		if err := json.Unmarshal(raw, b.targets[index]); err != nil {
+			return err
+		}
+	}
+	b.ran = true
+	return nil
+}
+
+type Future[Value any] struct {
+	value Value
+	batch *Batch
+}
+
+// NewFuture registers a command with the batch. Value panics until Run succeeds: reading a result
+// that was never fetched is an author bug, and a trap rolls the call back instead of returning a
+// zero score as if it were real.
+func NewFuture[Value any](batch *Batch, command any) *Future[Value] {
+	future := &Future[Value]{batch: batch}
+	batch.add(command, &future.value)
+	return future
+}
+
+func (f *Future[Value]) Value() Value {
+	if !f.batch.ran {
+		panic("rudder: batch result read before Run")
+	}
+	return f.value
+}
+
+// Command registers a raw host command with a batch, so an op with no generated accessor runs in
+// the same all-or-nothing batch as the generated ones. It is NOT an escape hatch for ops the
+// generator covers.
+func Command(batch *Batch, command any) *Future[struct{}] {
+	return NewFuture[struct{}](batch, command)
+}
+
+var dataHash string
+
+func SetDataHash(hash string) { dataHash = hash }
+
+// docEntry is the wire shape of one document, the same one the generated <Name>Entry declares.
+// DocPatch decodes into it because it is the only reader that does not know the generated type.
+type docEntry[Value any] struct {
+	Key       string    `json:"key"`
+	Value     Value     `json:"value"`
+	Version   Version   `json:"version"`
+	UpdatedAt time.Time `json:"updatedAt"`
+}
+
+// DocPatch is get, apply, put, one retry. It lives here rather than in generated code because it is
+// the only author operation with a loop in it, and generated code with a loop needs tests.
+//
+// Patch retries once on version_conflict, with the same idempotency key: a put that failed does
+// not use up its key.
+func DocPatch[Value any, Entry any](primitive string, owner Owner, key string, apply func(*Value) error, op []Op) (Entry, error) {
+	var entry Entry
+	for attempt := 0; attempt < 2; attempt++ {
+		current, err := One[docEntry[Value]](abi.DocGetParameters{Primitive: primitive, Owner: owner, Key: key})
+		if err != nil {
+			return entry, err
+		}
+		value := current.Value
+		if err := apply(&value); err != nil {
+			if errors.Is(err, Unchanged) {
+				return asEntry[Entry](key, current.Value, current.Version, current.UpdatedAt), nil
+			}
+			return entry, err
+		}
+		written, err := One[Written](abi.DocPutParameters{
+			Primitive: primitive, Owner: owner, Key: key,
+			Data: JSON(value), Version: int64(current.Version), OpKey: OpKey(op),
+		})
+		switch {
+		case err == nil:
+			return asEntry[Entry](key, value, written.Version, time.Time{}), nil
+		case !IsCode(err, abi.ErrorCodeVersionConflict):
+			return entry, err
+		}
+	}
+	return entry, Fail(abi.ErrorCodeVersionConflict, "document "+primitive+"/"+key+" changed twice while patching")
+}
+
+// asEntry builds the generated entry type from the four fields every entry has. It goes through
+// JSON because DocPatch is compiled once for a type the SDK cannot name; the generated struct is
+// the same shape docEntry is, so a failure here is a generator bug and traps the call.
+func asEntry[Entry any, Value any](key string, value Value, version Version, updatedAt time.Time) Entry {
+	var entry Entry
+	body, err := json.Marshal(docEntry[Value]{Key: key, Value: value, Version: version, UpdatedAt: updatedAt})
+	if err == nil {
+		err = json.Unmarshal(body, &entry)
+	}
+	if err != nil {
+		panic("rudder: generated document entry does not fit the wire shape: " + err.Error())
+	}
+	return entry
+}
+
+// catalogPage fits every catalog result: list and active answer {rows, truncated}, get answers
+// {row, found}. One shape is what lets every batched catalog read return *CatalogFuture[Row].
+type catalogPage struct {
+	Rows  []json.RawMessage `json:"rows"`
+	Row   json.RawMessage   `json:"row"`
+	Found bool              `json:"found"`
+}
+
+func (p catalogPage) raw() []json.RawMessage {
+	if p.Found {
+		return []json.RawMessage{p.Row}
+	}
+	return p.Rows
+}
+
+func CatalogAll[Row any](name string) ([]Row, error) {
+	return catalogRows[Row](abi.CatalogListParameters{Primitive: name, Limit: catalogLimit})
+}
+
+func CatalogWhere[Row any](name string, field string, equals any) ([]Row, error) {
+	return catalogRows[Row](abi.CatalogListParameters{
+		Primitive: name, Field: field, Eq: catalogEq(equals), Limit: catalogLimit,
+	})
+}
+
+func CatalogBy[Row any](name string, field string, equals any) (Row, bool, error) {
+	return catalogOne[Row](abi.CatalogGetParameters{Primitive: name, Field: field, Eq: catalogEq(equals)})
+}
+
+// CatalogActive is the rows whose schedule is open now and whose segment this owner matches, in
+// the declared order, both evaluated in the kernel. A zero Owner evaluates the schedule only.
+func CatalogActive[Row any](name string, owner Owner, field string, equals any) ([]Row, error) {
+	return catalogRows[Row](catalogActive(name, owner, field, equals, catalogLimit))
+}
+
+func CatalogActiveOne[Row any](name string, owner Owner, field string, equals any) (Row, bool, error) {
+	return catalogOne[Row](catalogActive(name, owner, field, equals, 1))
+}
+
+func catalogActive(name string, owner Owner, field string, equals any, limit int64) abi.CatalogActiveParameters {
+	return abi.CatalogActiveParameters{
+		Primitive: name, Owner: owner, Field: field, Eq: catalogEq(equals), Limit: limit,
+	}
+}
+
+func catalogRows[Row any](command any) ([]Row, error) {
+	page, err := One[catalogPage](command)
+	if err != nil {
+		return nil, err
+	}
+	return decodeRows[Row](page.raw())
+}
+
+func catalogOne[Row any](command any) (Row, bool, error) {
+	rows, err := catalogRows[Row](command)
+	var row Row
+	if err != nil || len(rows) == 0 {
+		return row, false, err
+	}
+	return rows[0], true, nil
+}
+
+func decodeRows[Row any](items []json.RawMessage) ([]Row, error) {
+	rows := make([]Row, 0, len(items))
+	for _, item := range items {
+		var row Row
+		if err := json.Unmarshal(item, &row); err != nil {
+			return nil, err
+		}
+		rows = append(rows, row)
+	}
+	return rows, nil
+}
+
+// CatalogFuture is the batched form of a catalog read. The rows decode when the value is read
+// rather than in Run, because only the generated package knows the row type; a row that does not
+// fit it is a generated-code bug, so it traps the call the way Value does before Run.
+type CatalogFuture[Row any] struct {
+	page *Future[catalogPage]
+}
+
+func newCatalogFuture[Row any](batch *Batch, command any) *CatalogFuture[Row] {
+	return &CatalogFuture[Row]{page: NewFuture[catalogPage](batch, command)}
+}
+
+func (f *CatalogFuture[Row]) Value() []Row {
+	rows, err := decodeRows[Row](f.page.Value().raw())
+	if err != nil {
+		panic("rudder: catalog row does not fit the generated type: " + err.Error())
+	}
+	return rows
+}
+
+func (f *CatalogFuture[Row]) One() (Row, bool) {
+	rows := f.Value()
+	if len(rows) == 0 {
+		var row Row
+		return row, false
+	}
+	return rows[0], true
+}
+
+func CatalogAllFuture[Row any](batch *Batch, name string) *CatalogFuture[Row] {
+	return newCatalogFuture[Row](batch, abi.CatalogListParameters{Primitive: name, Limit: catalogLimit})
+}
+
+func CatalogWhereFuture[Row any](batch *Batch, name string, field string, equals any) *CatalogFuture[Row] {
+	return newCatalogFuture[Row](batch, abi.CatalogListParameters{
+		Primitive: name, Field: field, Eq: catalogEq(equals), Limit: catalogLimit,
+	})
+}
+
+func CatalogByFuture[Row any](batch *Batch, name string, field string, equals any) *CatalogFuture[Row] {
+	return newCatalogFuture[Row](batch, abi.CatalogGetParameters{Primitive: name, Field: field, Eq: catalogEq(equals)})
+}
+
+func CatalogActiveFuture[Row any](batch *Batch, name string, owner Owner, field string, equals any) *CatalogFuture[Row] {
+	return newCatalogFuture[Row](batch, catalogActive(name, owner, field, equals, catalogLimit))
+}
+
+func CatalogActiveOneFuture[Row any](batch *Batch, name string, owner Owner, field string, equals any) *CatalogFuture[Row] {
+	return newCatalogFuture[Row](batch, catalogActive(name, owner, field, equals, 1))
+}
+
+func catalogEq(equals any) json.RawMessage {
+	if equals == nil {
+		return nil
+	}
+	body, err := json.Marshal(equals)
+	if err != nil {
+		panic(err)
+	}
+	return body
+}
+
+// Grant pays a reward to an owner. Concurrent grants to the same owner are safe.
+func (c *Context) Grant(owner Owner, reward Reward, op ...Op) error {
+	return call(abi.RewardGrantParameters{
+		Owner:      owner,
+		Currencies: amounts(reward.Currencies),
+		Items:      stacks(reward.Items),
+		OpKey:      OpKey(op),
+	}, nil)
+}
+
+func amounts(values map[string]int64) []abi.Amount {
+	out := make([]abi.Amount, 0, len(values))
+	for _, currency := range sortedKeys(values) {
+		out = append(out, abi.Amount{Currency: currency, Amount: values[currency]})
+	}
+	return out
+}
+
+func stacks(values map[string]int64) []abi.Stack {
+	out := make([]abi.Stack, 0, len(values))
+	for _, item := range sortedKeys(values) {
+		out = append(out, abi.Stack{Item: item, Quantity: values[item]})
+	}
+	return out
+}
+
+func sortedKeys(values map[string]int64) []string {
+	keys := make([]string, 0, len(values))
+	for key := range values {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	return keys
+}

go.mod

@@ -0,0 +1,3 @@
+module hub.rudder.build/rudder/rudder-module-go
+
+go 1.27.0

native.go

@@ -0,0 +1,17 @@
+//go:build !wasip1
+
+package rudder
+
+const nativeBuildMessage = "rudder modules run only when built with GOOS=wasip1 GOARCH=wasm"
+
+func readInput() []byte {
+	panic(nativeBuildMessage)
+}
+
+func hostCall(request []byte) []byte {
+	panic(nativeBuildMessage)
+}
+
+func writeOutput(body []byte) {
+	panic(nativeBuildMessage)
+}

operations.go

@@ -0,0 +1,115 @@
+package rudder
+
+import (
+	"encoding/json"
+
+	"hub.rudder.build/rudder/rudder-module-go/abi"
+)
+
+type Ledger struct{}
+
+func (Ledger) Balance(parameters abi.LedgerBalanceParameters) (*abi.LedgerBalanceResult, error) {
+	return callResult[abi.LedgerBalanceResult](parameters)
+}
+
+func (Ledger) Balances(parameters abi.LedgerBalancesParameters) (*abi.LedgerBalancesResult, error) {
+	return callResult[abi.LedgerBalancesResult](parameters)
+}
+
+func (Ledger) Credit(parameters abi.LedgerCreditParameters) (*abi.LedgerCreditResult, error) {
+	return callResult[abi.LedgerCreditResult](parameters)
+}
+
+func (Ledger) Debit(parameters abi.LedgerDebitParameters) (*abi.LedgerDebitResult, error) {
+	return callResult[abi.LedgerDebitResult](parameters)
+}
+
+func (Ledger) History(parameters abi.LedgerHistoryParameters) (*abi.LedgerHistoryResult, error) {
+	return callResult[abi.LedgerHistoryResult](parameters)
+}
+
+type Inventory struct{}
+
+func (Inventory) Get(parameters abi.InventoryGetParameters) (*abi.InventoryGetResult, error) {
+	return callResult[abi.InventoryGetResult](parameters)
+}
+
+func (Inventory) List(parameters abi.InventoryListParameters) (*abi.InventoryListResult, error) {
+	return callResult[abi.InventoryListResult](parameters)
+}
+
+func (Inventory) Has(parameters abi.InventoryHasParameters) (*abi.InventoryHasResult, error) {
+	return callResult[abi.InventoryHasResult](parameters)
+}
+
+func (Inventory) Grant(parameters abi.InventoryGrantParameters) error {
+	return call(parameters, nil)
+}
+
+func (Inventory) Consume(parameters abi.InventoryConsumeParameters) error {
+	return call(parameters, nil)
+}
+
+type Storage struct{}
+
+func (Storage) Get(parameters abi.StorageGetParameters) (*abi.StorageGetResult, error) {
+	return callResult[abi.StorageGetResult](parameters)
+}
+
+func (Storage) Set(parameters abi.StorageSetParameters) error {
+	return call(parameters, nil)
+}
+
+type ProjectStorage struct{}
+
+func (ProjectStorage) Get(parameters abi.ProjectStorageGetParameters) (*abi.ProjectStorageGetResult, error) {
+	return callResult[abi.ProjectStorageGetResult](parameters)
+}
+
+func (ProjectStorage) Set(parameters abi.ProjectStorageSetParameters) error {
+	return call(parameters, nil)
+}
+
+type Segments struct{}
+
+func (Segments) Match(parameters abi.SegmentsMatchParameters) (*abi.SegmentsMatchResult, error) {
+	return callResult[abi.SegmentsMatchResult](parameters)
+}
+
+func (Segments) Bucket(parameters abi.SegmentsBucketParameters) (*abi.SegmentsBucketResult, error) {
+	return callResult[abi.SegmentsBucketResult](parameters)
+}
+
+type Events struct{}
+
+func (Events) Emit(parameters abi.EventsEmitParameters) error {
+	return call(parameters, nil)
+}
+
+type Data struct{}
+
+func (Data) Exec(parameters abi.DataExecParameters) (*abi.DataExecResult, error) {
+	return callResult[abi.DataExecResult](parameters)
+}
+
+type Modules struct{}
+
+func (Modules) Call(module string, function string, args any) (json.RawMessage, error) {
+	body, err := json.Marshal(args)
+	if err != nil {
+		return nil, err
+	}
+	var result abi.ModulesCallResult
+	if err := call(abi.ModulesCallParameters{Module: module, Function: function, Arguments: body}, &result); err != nil {
+		return nil, err
+	}
+	return result.Value, nil
+}
+
+func callResult[Result any](parameters any) (*Result, error) {
+	var result Result
+	if err := call(parameters, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}

rudder.go

@@ -0,0 +1,179 @@
+package rudder
+
+import (
+	"encoding/json"
+	"errors"
+	"reflect"
+	"slices"
+	"sort"
+	"time"
+
+	"hub.rudder.build/rudder/rudder-module-go/abi"
+)
+
+type Handler struct {
+	run       func(ctx *Context, args json.RawMessage) (any, error)
+	arguments reflect.Type
+	result    reflect.Type
+}
+
+type Option func(function *function)
+
+type function struct {
+	handler Handler
+	errors  []string
+}
+
+type Context struct {
+	Trigger     string
+	Player      *abi.Player
+	Config      json.RawMessage
+	Now         time.Time
+	Module      string
+	Environment string
+
+	Ledger         Ledger
+	Inventory      Inventory
+	Storage        Storage
+	ProjectStorage ProjectStorage
+	Segments       Segments
+	Events         Events
+	Modules        Modules
+	Data           Data
+}
+
+type Error struct {
+	Code    string
+	Message string
+}
+
+func (e *Error) Error() string {
+	return e.Code + ": " + e.Message
+}
+
+func Fail(code string, message string) error {
+	return &Error{Code: code, Message: message}
+}
+
+var functions = map[string]*function{}
+
+func Register(name string, handler Handler, options ...Option) {
+	registered := &function{handler: handler, errors: []string{}}
+	for _, option := range options {
+		option(registered)
+	}
+	functions[name] = registered
+}
+
+func Errors(codes ...string) Option {
+	return func(function *function) {
+		function.errors = append(function.errors, codes...)
+	}
+}
+
+func Typed[Arguments any, Result any](handler func(ctx *Context, args Arguments) (Result, error)) Handler {
+	return Handler{
+		run: func(ctx *Context, raw json.RawMessage) (any, error) {
+			var args Arguments
+			if len(raw) > 0 {
+				if err := json.Unmarshal(raw, &args); err != nil {
+					return nil, Fail(abi.ErrorCodeInvalidParameters, err.Error())
+				}
+			}
+			return handler(ctx, args)
+		},
+		arguments: reflect.TypeFor[Arguments](),
+		result:    reflect.TypeFor[Result](),
+	}
+}
+
+func runHandle() {
+	output, err := invoke(readInput())
+	if err != nil {
+		var failure *Error
+		if !errors.As(err, &failure) {
+			failure = &Error{Code: abi.ErrorCodeInternal, Message: err.Error()}
+		}
+		output = abi.Output{Error: &abi.ErrorBody{Code: failure.Code, Message: failure.Message}}
+	}
+	body, err := json.Marshal(output)
+	if err != nil {
+		panic(err)
+	}
+	writeOutput(body)
+}
+
+func invoke(input []byte) (abi.Output, error) {
+	var request abi.Input
+	if err := json.Unmarshal(input, &request); err != nil {
+		return abi.Output{}, err
+	}
+	registered, ok := functions[request.Function]
+	if !ok {
+		return abi.Output{}, Fail(abi.ErrorCodeFunctionNotFound, "function "+request.Function+" is not registered")
+	}
+	now, err := time.Parse(time.RFC3339Nano, request.Context.Now)
+	if err != nil {
+		return abi.Output{}, err
+	}
+	ctx := &Context{
+		Trigger:     request.Context.Trigger,
+		Player:      request.Context.Player,
+		Config:      request.Context.Config,
+		Now:         now,
+		Module:      request.Context.Module,
+		Environment: request.Context.Environment,
+	}
+	result, err := registered.handler.run(ctx, request.Arguments)
+	if err != nil {
+		return abi.Output{}, err
+	}
+	body, err := json.Marshal(result)
+	if err != nil {
+		return abi.Output{}, err
+	}
+	return abi.Output{Result: body}, nil
+}
+
+func runDescribe() {
+	names := make([]string, 0, len(functions))
+	for name := range functions {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	described := make([]abi.DescribedFunction, 0, len(names))
+	for _, name := range names {
+		registered := functions[name]
+		errorCodes := slices.Clone(registered.errors)
+		slices.Sort(errorCodes)
+		described = append(described, abi.DescribedFunction{
+			Name:   name,
+			Input:  mustSchema(name+" arguments", registered.handler.arguments),
+			Output: mustSchema(name+" result", registered.handler.result),
+			Errors: slices.Compact(errorCodes),
+		})
+	}
+	body, err := json.Marshal(abi.Describe{Functions: described, DataHash: dataHash})
+	if err != nil {
+		panic(err)
+	}
+	writeOutput(body)
+}
+
+func call(parameters any, result any) error {
+	request, err := json.Marshal(parameters)
+	if err != nil {
+		return err
+	}
+	var response abi.CallResponse
+	if err := json.Unmarshal(hostCall(request), &response); err != nil {
+		return err
+	}
+	if response.Error != nil {
+		return &Error{Code: response.Error.Code, Message: response.Error.Message}
+	}
+	if result == nil {
+		return nil
+	}
+	return json.Unmarshal(response.Result, result)
+}

schema.go

@@ -0,0 +1,232 @@
+package rudder
+
+import (
+	"encoding"
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"regexp"
+	"slices"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type schema struct {
+	Type                 string             `json:"type,omitempty"`
+	Format               string             `json:"format,omitempty"`
+	Nullable             bool               `json:"nullable,omitempty"`
+	Properties           map[string]*schema `json:"properties,omitempty"`
+	Required             []string           `json:"required,omitempty"`
+	Items                *schema            `json:"items,omitempty"`
+	AdditionalProperties *schema            `json:"additionalProperties,omitempty"`
+	Enum                 []any              `json:"enum,omitempty"`
+	Minimum              *float64           `json:"minimum,omitempty"`
+	Maximum              *float64           `json:"maximum,omitempty"`
+	MinLength            *uint64            `json:"minLength,omitempty"`
+	MaxLength            *uint64            `json:"maxLength,omitempty"`
+	Pattern              string             `json:"pattern,omitempty"`
+}
+
+var (
+	timeType          = reflect.TypeFor[time.Time]()
+	jsonMarshalerType = reflect.TypeFor[json.Marshaler]()
+	textMarshalerType = reflect.TypeFor[encoding.TextMarshaler]()
+)
+
+func mustSchema(label string, t reflect.Type) json.RawMessage {
+	body, err := json.Marshal(schemaOf(t, map[reflect.Type]bool{}))
+	if err != nil {
+		panic(fmt.Sprintf("rudder: %s schema: %v", label, err))
+	}
+	return body
+}
+
+func schemaOf(t reflect.Type, visiting map[reflect.Type]bool) *schema {
+	if t.Kind() == reflect.Pointer {
+		element := schemaOf(t.Elem(), visiting)
+		element.Nullable = true
+		return element
+	}
+	if t == timeType {
+		return &schema{Type: "string", Format: "date-time"}
+	}
+	if t.Implements(jsonMarshalerType) || reflect.PointerTo(t).Implements(jsonMarshalerType) {
+		return &schema{}
+	}
+	if t.Implements(textMarshalerType) || reflect.PointerTo(t).Implements(textMarshalerType) {
+		return &schema{Type: "string"}
+	}
+	switch t.Kind() {
+	case reflect.Bool:
+		return &schema{Type: "boolean"}
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return &schema{Type: "integer"}
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		zero := 0.0
+		return &schema{Type: "integer", Minimum: &zero}
+	case reflect.Float32, reflect.Float64:
+		return &schema{Type: "number"}
+	case reflect.String:
+		return &schema{Type: "string"}
+	case reflect.Interface:
+		return &schema{}
+	case reflect.Slice:
+		if t.Elem().Kind() == reflect.Uint8 {
+			return &schema{Type: "string", Format: "byte"}
+		}
+		return &schema{Type: "array", Items: schemaOf(t.Elem(), visiting)}
+	case reflect.Array:
+		return &schema{Type: "array", Items: schemaOf(t.Elem(), visiting)}
+	case reflect.Map:
+		if t.Elem().Kind() == reflect.Interface {
+			return &schema{}
+		}
+		return &schema{Type: "object", AdditionalProperties: schemaOf(t.Elem(), visiting)}
+	case reflect.Struct:
+		object := &schema{Type: "object", Properties: map[string]*schema{}}
+		addFields(object, t, visiting)
+		slices.Sort(object.Required)
+		return object
+	}
+	panic(fmt.Sprintf("rudder: type %s cannot be encoded as JSON", t))
+}
+
+func addFields(object *schema, t reflect.Type, visiting map[reflect.Type]bool) {
+	if visiting[t] {
+		panic(fmt.Sprintf("rudder: recursive type %s is not supported in function arguments and results", t))
+	}
+	visiting[t] = true
+	defer delete(visiting, t)
+	var embedded []reflect.Type
+	for field := range t.Fields() {
+		tag := field.Tag.Get("json")
+		if tag == "-" {
+			continue
+		}
+		name, options, _ := strings.Cut(tag, ",")
+		fieldType := field.Type
+		if field.Anonymous && name == "" {
+			if fieldType.Kind() == reflect.Pointer {
+				fieldType = fieldType.Elem()
+			}
+			if fieldType.Kind() == reflect.Struct {
+				embedded = append(embedded, fieldType)
+				continue
+			}
+		}
+		if !field.IsExported() {
+			continue
+		}
+		if name == "" {
+			name = field.Name
+		}
+		property := schemaOf(fieldType, visiting)
+		applyConstraints(property, t.String()+"."+field.Name, field.Tag.Get("rudder"))
+		object.Properties[name] = property
+		if !strings.Contains(","+options+",", ",omitempty,") && !strings.Contains(","+options+",", ",omitzero,") {
+			object.Required = append(object.Required, name)
+		}
+	}
+	for _, embeddedType := range embedded {
+		inner := &schema{Properties: map[string]*schema{}}
+		addFields(inner, embeddedType, visiting)
+		required := map[string]bool{}
+		for _, name := range inner.Required {
+			required[name] = true
+		}
+		for name, property := range inner.Properties {
+			if _, ok := object.Properties[name]; ok {
+				continue
+			}
+			object.Properties[name] = property
+			if required[name] {
+				object.Required = append(object.Required, name)
+			}
+		}
+	}
+}
+
+func applyConstraints(property *schema, field string, tag string) {
+	for tag != "" {
+		var entry string
+		if strings.HasPrefix(tag, "pattern=") {
+			entry, tag = tag, ""
+		} else {
+			entry, tag, _ = strings.Cut(tag, ",")
+		}
+		key, value, _ := strings.Cut(entry, "=")
+		if err := applyConstraint(property, key, value); err != nil {
+			panic(fmt.Sprintf("rudder: invalid rudder tag on %s: %s: %v", field, entry, err))
+		}
+	}
+}
+
+func applyConstraint(property *schema, key string, value string) error {
+	numeric := property.Type == "integer" || property.Type == "number"
+	switch key {
+	case "min", "max":
+		if !numeric {
+			return fmt.Errorf("%s needs an integer or number field, got %q", key, property.Type)
+		}
+		bound, err := strconv.ParseFloat(value, 64)
+		if err != nil {
+			return err
+		}
+		if key == "min" {
+			property.Minimum = &bound
+		} else {
+			property.Maximum = &bound
+		}
+	case "minLength", "maxLength":
+		if property.Type != "string" {
+			return fmt.Errorf("%s needs a string field, got %q", key, property.Type)
+		}
+		length, err := strconv.ParseUint(value, 10, 64)
+		if err != nil {
+			return err
+		}
+		if key == "minLength" {
+			property.MinLength = &length
+		} else {
+			property.MaxLength = &length
+		}
+	case "pattern":
+		if property.Type != "string" {
+			return fmt.Errorf("pattern needs a string field, got %q", property.Type)
+		}
+		if _, err := regexp.Compile(value); err != nil {
+			return err
+		}
+		property.Pattern = value
+	case "format":
+		if property.Type == "" || value == "" {
+			return fmt.Errorf("format needs a typed field and a value")
+		}
+		property.Format = value
+	case "enum":
+		for option := range strings.SplitSeq(value, "|") {
+			switch property.Type {
+			case "string":
+				property.Enum = append(property.Enum, option)
+			case "integer":
+				parsed, err := strconv.ParseInt(option, 10, 64)
+				if err != nil {
+					return err
+				}
+				property.Enum = append(property.Enum, parsed)
+			case "number":
+				parsed, err := strconv.ParseFloat(option, 64)
+				if err != nil {
+					return err
+				}
+				property.Enum = append(property.Enum, parsed)
+			default:
+				return fmt.Errorf("enum needs a string, integer or number field, got %q", property.Type)
+			}
+		}
+	default:
+		return fmt.Errorf("unknown constraint %q; use min, max, minLength, maxLength, pattern, enum or format", key)
+	}
+	return nil
+}

wasm.go

@@ -0,0 +1,46 @@
+//go:build wasip1
+
+package rudder
+
+import "unsafe"
+
+//go:wasmimport rudder_v1 input_len
+func importInputLength() uint32
+
+//go:wasmimport rudder_v1 input
+func importInput(pointer unsafe.Pointer)
+
+//go:wasmimport rudder_v1 call
+func importCall(pointer unsafe.Pointer, length uint32) uint32
+
+//go:wasmimport rudder_v1 result
+func importResult(pointer unsafe.Pointer)
+
+//go:wasmimport rudder_v1 output
+func importOutput(pointer unsafe.Pointer, length uint32)
+
+//go:wasmexport handle
+func handle() {
+	runHandle()
+}
+
+//go:wasmexport describe
+func describe() {
+	runDescribe()
+}
+
+func readInput() []byte {
+	input := make([]byte, importInputLength())
+	importInput(unsafe.Pointer(unsafe.SliceData(input)))
+	return input
+}
+
+func hostCall(request []byte) []byte {
+	response := make([]byte, importCall(unsafe.Pointer(unsafe.SliceData(request)), uint32(len(request))))
+	importResult(unsafe.Pointer(unsafe.SliceData(response)))
+	return response
+}
+
+func writeOutput(body []byte) {
+	importOutput(unsafe.Pointer(unsafe.SliceData(body)), uint32(len(body)))
+}