Record the Chisel/Studio findings, and fix the scoping model (§13.13–13.15)

[kaidesu]

Overview

Building Chisel (a retained-mode widget toolkit) and Studio (a sprite and tilemap editor shell) was the first time a substantial Ghost library — rather than a script — was written against 1.0. It surfaced a cluster of defects the standard-library-shaped gap list in §12 would never have found, because they are all about scoping, module boundaries and class shape.

Two commits. The first records every finding in §12/§13/§14. The second fixes the three highest-damage ones, which are one design question wearing three faces — §14 decision 9 settles it as assignment walks the enclosing chain, and blocks have scopes of their own.

Every behavior recorded here was executed against a build of the interpreter, not inferred from the specification, and each callout names the code path responsible.

scale = 1
function set(n) { scale = n }
set(4)
scale            // was 1; now 4                                  (§13.13)

handlers = []
for (name in ["a", "b"]) {
    handlers.push(function () { return name })
}
handlers[0]()    // was: name error: `name` is not defined; now "a"  (§13.14)

x = 1
if (true) { x = 2; y = 99 }
x                // 2 — assignment still reaches the outer x
y                // was 99; now: name error: `y` is not defined    (§13.15)

Two findings were cases where the specification already described the behavior we want and the interpreter did not implement it (§13.15 against §8.3, §13.17 against §8.8). §13.15 is now fixed; §13.17 remains open with §8.8 pointing at it.

Changes

Added

• §13.13–§13.20, a new block of defect callouts with a preamble explaining their provenance and why they are appended rather than interleaved into the existing damage ranking (renumbering §13.1–§13.12 would invalidate every cross-reference in the document and in the commit history).
• §14 decision 9 (the scoping model — decided and done) and decision 10 (module export surface — open).
• Environment.Assign, which walks the enclosing chain exactly as Get does and rebinds a name wherever it is already bound, built on a rebind helper that Set now shares so "update in place" exists once rather than twice.
• Scope.Enclose/Scope.Release and Environment.Capture, the block-scope reuse that keeps this from allocating per loop iteration.
• evaluator/scoping_test.go — five tables covering the fix.
• §12 gains the two small arithmetic gaps the same work found: math.floorDiv(a, b), and the missing %= (+=, -=, *=, /= all work).

Fixed

• §13.13 — assignment now walks the chain. The evaluator's bind is the single point every name-assignment goes through, so plain =, both destructuring forms, the compound operators and ++/-- all reach an outer variable the same way.
• §13.14 — both loops bind their control variables once per iteration, which replaces the save-and-restore dance entirely: nothing is written to the enclosing scope, so there is nothing to put back. In the C-style loop the increment runs at the top of each iteration after the first, against that iteration's own scope — incrementing in the iteration a closure just captured would move the value out from under it.
• §13.15 — the scope is introduced by the statements that own a block rather than by evaluateBlock, because two of its callers must not get one: a class or trait body is evaluated in the environment collecting its members, and a function body already runs in its own frame.
• One stale item from the source report is corrected rather than copied: list.length without parentheses already raises a proper property error. The report's "division always promotes to float" claim is likewise corrected — 7 / 2 is 3.5 but 6 / 3 is 2; the real gap is the absence of floor division, filed in §12.

Changed

• §8.3 rewritten to describe the language as built, with the migration form shown.
• §8.8's bare-sibling-call bullet carries the §13.17 caveat and says to write this.method() until it is fixed.
• §14 decision 5 (no statics) reaffirmed, with the cost it imposes on library shape written down rather than assumed.

Related issues

None open for these; this PR is the record.

Additional context

One breaking change, called out in both §13.15 and §8.3: a name first assigned inside a branch no longer outlives it, so if (c) { r = 1 } else { r = 2 } followed by a read of r now needs r assigned before the branch. All 41 programs in examples/ produce byte-identical output before and after, so the pattern is rarer in practice than it looks.

The rejected alternative was a declaration keyword (let/var) — safer semantics, and the one every reader of modern JS already has loaded. It was not chosen because it costs a reversal of §8.3's most prominently documented stance, a new keyword in a language that has kept its surface deliberately small (§4), and a migration for every line of existing Ghost. The known cost of the path taken is recorded rather than glossed: a method-local whose name matches a sibling method rebinds that method, which block scoping contains but does not eliminate.

Performance. A scope per block execution is an allocation per loop iteration, which initially cost up to 8.5× the allocated bytes and 1.8× the wall time on the loop-heavy cases in evaluator/benchmark_test.go. Scope reuse plus capture tracking brings allocation back to parity on every benchmark; wall time is 1.03×–1.21×, the intrinsic cost of the extra link each name lookup crosses. Reuse is safe across goroutines by construction — every concurrent entry into Ghost code (an http.handle callback, an embedder's Call) runs in a function frame of its own, so a block's environment is a child of that frame rather than of anything shared.

Verification: go build ./..., go test ./..., go test -race ./..., go vet ./... and gofmt -l . all clean; benchmarks and all 41 examples diffed against a baseline build of the parent commit.

Still open from this batch, in damage order: §13.16 (module exports everything), §13.17 (bare sibling call loses the receiver — independent of decision 9 and fixable on its own), §13.18, §13.19.