// Settled indicates if a call to Await will cause a blocking behavior, or
	// if the result will be immediately returned.
	Settled() bool

This method

func (s *syncPromise[T]) Settled() bool {
	return atomic.LoadInt32(&s.settled) == 1
}

will return true once this code has executed

func (s *syncPromise[T]) resolve(v T) {
	if atomic.CompareAndSwapInt32(&s.settled, 0, 1) {

but potentially before this code has executed

		s.result = result[T]{value: v}
		close(s.done)

which means that this code

func (s *syncPromise[T]) Await(ctx context.Context) (T, error) {
	select {
	case <-ctx.Done():
		var zerov T
		return zerov, ctx.Err()
	case <-s.done:
		return s.result.value, s.result.err
	}
}

would block, violating the contract of the interface.

I think you can solve this in a number of ways... maybe this is one?

type syncPromise[T any] struct {
	val  T
	err  error
	done chan struct{}
}

func NewPromise[T any](fn func() (T, error)) Promise[T] {
	p := &syncPromise[T]{done: make(chan struct{})}
	go func() { p.val, p.err = fn(); close(p.done) }()
	return p
}

func (p *syncPromise[T]) Settled() bool {
	select {
	case <-p.done:
		return true
	default:
		return false
	}
}

func (p *syncPromise[T]) Await(ctx context.Context) (T, error) {
	select {
	case <-p.done:
		return p.val, p.err
	case <-ctx.Done():
		var zero T
		return zero, ctx.Err()
	}
}

edit: golfed it a bit to remove the need for result[T]