# `Beaver.MLIR.Transform.Schedule`

Deterministic discovery and resolution of Transform Tune schedules.

Schedules can be authored using Elixir DSL (`Beaver.MLIR.Transform.Schedule.DSL`)
or supplied as raw MLIR modules. A resolved schedule is immutable BEAM data:
MLIR bytecode, printable text, the active choices, and a stable digest.
Resolution writes choices back to `transform.tune.knob` and `transform.tune.alternatives`,
so replay does not invoke the resolver or repeat a search.

# `input`

```elixir
@type input() ::
  Beaver.MLIR.Module.t()
  | Beaver.MLIR.Operation.t()
  | binary()
  | {:text, binary()}
  | {:bytecode, binary()}
  | Beaver.MLIR.Transform.Schedule.Resolved.t()
```

# `analyze`

```elixir
@spec analyze(
  input(),
  keyword()
) ::
  {:ok, Beaver.MLIR.Transform.Schedule.Analysis.t()}
  | {:error, Beaver.MLIR.Transform.Error.t()}
```

Discovers Tune choices and SMT constraints without executing the schedule.

# `cache_identity`

```elixir
@spec cache_identity(Beaver.MLIR.Transform.Schedule.Resolved.t() | binary()) ::
  tuple()
```

Returns the stable identity included in incremental compilation cache keys.

# `constraints`

```elixir
@spec constraints(
  input(),
  keyword()
) ::
  {:ok, [Beaver.MLIR.Transform.Schedule.Constraint.t()]}
  | {:error, Beaver.MLIR.Transform.Error.t()}
```

Returns exported SMT constraints even when no solver is configured.

# `enumerate`

```elixir
@spec enumerate(
  input(),
  keyword()
) :: {:ok, [map()]} | {:error, Beaver.MLIR.Transform.Error.t()}
```

Enumerates active Tune choices in stable IR and option order.

Existing selections remain fixed. Choices nested in an alternatives region
are included only when that region is selected by the candidate. Arbitrary
non-array knob domains remain inspectable but require an explicit resolver.

# `resolve`

```elixir
@spec resolve(input(), map() | function() | module() | {module(), term()}, keyword()) ::
  {:ok, Beaver.MLIR.Transform.Schedule.Resolved.t()}
  | {:error, Beaver.MLIR.Transform.Error.t()}
```

Resolves active Tune choices from a map, function, or resolver behaviour.

# `resolve!`

```elixir
@spec resolve!(input(), map() | function() | module() | {module(), term()}, keyword()) ::
  Beaver.MLIR.Transform.Schedule.Resolved.t()
```

Bang variant of `resolve/3`.

# `sequence`

Returns the entry-point symbol carried by a resolved schedule.

# `serialize`

```elixir
@spec serialize(Beaver.MLIR.Transform.Schedule.Resolved.t(), :bytecode | :text) ::
  binary()
```

Serializes a resolved schedule as replayable MLIR bytecode or text.