Irrelevant of whether I think that splicing or non-splicing semantics are more helpful, I agree with Alex that the R7RS is crystal-clear on this point.

In 5.3.2 where the semantics of internal definitions is described (and the question is just about what happens with internal definition in the body of a let(rec)-syntax), the transformation of a body with internal definitions into one without (but using letrec*) is described.

If you apply that transformation to let(rec)-syntax, you get non-splicing semantics.

R7RS section 5.3.2 inserts an interesting sentence into that paragraph:

Note that such a body might not be apparent until after expansion
of other syntax.

If it weren't for the mentions of let-syntax and letrec-syntax in the
preceding sentence, which were absent from the R4RS, someone might interpret
that sentence as suggesting the full extent of a body containing let-syntax
or letrec-syntax might not be apparent until after macro-expansion and
splicing of any definitions that result.

That sentence was also absent from the R5RS where let-syntax and letrec-seyntax were mentioned.

In any case, if someone had an argument that because of this sentence internal definitions of let(rec)-syntax where spliced in the surrounding body, that same argument would also work for any other bindings construct like let or lambda.

Can you comment on what you believe was the intended purpose of that new
sentence?

I would have guessed it takes about something like:

(define-syntax foo

(syntax-rules () ((foo . body) (let () . body))))

(foo (define x 1) x)

Without expanding foo, one cannot tell whether (define x 1) appears inside a (new) body or not.

As for an erratum: The only erratum that needs to be issued ts for the appendix: Language Changes, "Incompatibilities with R6RS". It says the list is not authoritative, and is possibly incomplete.

So here we have such an incompleteness because let(rec)-syntax is not mentioned. I think the (unofficial) list of errata is a good place to add this.

For R7RS-large we can look forward and add a let(rec)-syntax/splicing.

There are some edge cases that might need specification, though:

(let ()

(let-syntax/splicing ((foo (syntax-rules () ((foo) 'foo)))

(define-syntax foo (syntax-rules () ((foo) 'bar)))

(foo)))

Does this evaluate to foo, bar, or is it an error?

Or, what happens if let-syntax/splicing is used in an expression context where the is no surrounding body?

Marc