onejs-sl 0.2.0 → 0.3.0

package/src/lang/builtins.ts

@@ -45,13 +45,12 @@ const name = (op: number): string => {
 const val = (v: Num): Val => (typeof v === "number" ? (sl.float(v) as unknown as Val) : v)
 
 /**
- * Asserts an operand's width where the two backends would otherwise part ways.
+ * Asserts an operand's width where the backends would otherwise part ways.
  *
- * The VM keeps every value in a float4 register and writes `a.xy` or `a.rgb`
- * whatever it was handed, so a noise call on a float3 quietly works there. The
- * generated HLSL passes the real type to `sl_valueNoise(float2)` and either
- * truncates with a warning or fails to compile. Neither outcome is one an
- * author should discover after ejecting, so the narrow ops say so here.
+ * The generated HLSL passes the real type to `sl_valueNoise(float2)` and either
+ * truncates with a warning or fails to compile, while a browser may accept it.
+ * Neither outcome is one an author should discover in a build, so the narrow
+ * ops say so here.
  */
 function widthMustBe(fn: string, v: Num, want: 1 | 2 | 3 | 4, why: string): Val {
     const got = typeof v === "number" ? 1 : v.width
@@ -146,7 +145,7 @@ function octaves(fn: string, v: Num | undefined): number {
     if (v === undefined) return 3
     if (typeof v !== "number") {
         throw new SLError(
-            `${fn}'s octave count is baked into the instruction, so it has to be a constant. ` +
+            `${fn}'s octave count is part of the operation, so it has to be a constant. ` +
             `A uniform or a computed value cannot change how many octaves the shader runs.`,
         )
     }

package/src/lang/check.ts

@@ -28,8 +28,8 @@
  * is refused with the reason.
  */
 
-import { DERIVED_INPUTS, INPUTS } from "../ir"
-import { VM_TEXTURES, VM_UNIFORMS } from "../ops"
+import { DERIVED_INPUTS, INPUTS, tooManyTextures, tooManyUniforms } from "../ir"
+import { TEXTURE_SLOTS, UNIFORM_SLOTS } from "../ops"
 import { SL_GLSL_HINT } from "../ops"
 import { BUILTINS, NOT_YET } from "./builtins"
 import { SL_SDF_SHAPES } from "../shapes"
@@ -161,15 +161,9 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
         if (!uniforms.has(u.name)) uniforms.set(u.name, u)
     }
     attempt(() => {
-        if (uniforms.size <= VM_UNIFORMS) return
-        const over = unit.uniforms[VM_UNIFORMS]!
-        fail(
-            `this file declares ${uniforms.size} uniforms and a program may hold ${VM_UNIFORMS}. ` +
-            `That is the size of the VM's uniform array; past it a slot reads the last one instead ` +
-            `of its own, so it is refused here rather than rendered wrong. Pack related values into ` +
-            `a float4.`,
-            over.pos, over.name.length,
-        )
+        if (uniforms.size <= UNIFORM_SLOTS) return
+        const over = unit.uniforms[UNIFORM_SLOTS]!
+        fail(tooManyUniforms(uniforms.size, "file"), over.pos, over.name.length)
     })
 
     for (const t of unit.textures) {
@@ -180,14 +174,9 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
         if (!textures.has(t.name)) textures.set(t.name, t)
     }
     attempt(() => {
-        if (textures.size <= VM_TEXTURES) return
-        const over = unit.textures[VM_TEXTURES]!
-        fail(
-            `this file declares ${textures.size} textures and a program may sample ${VM_TEXTURES}. ` +
-            `The VM shader declares four samplers; a fifth would sample the fourth in the browser ` +
-            `and its own after an eject, which is two different pictures from one file.`,
-            over.pos, over.name.length,
-        )
+        if (textures.size <= TEXTURE_SLOTS) return
+        const over = unit.textures[TEXTURE_SLOTS]!
+        fail(tooManyTextures(textures.size, "file"), over.pos, over.name.length)
     })
 
     for (const c of unit.consts) {

package/src/lang/index.ts

@@ -8,7 +8,7 @@
  *     import { parse } from "onejs-sl"
  *
  *     const plasma = parse(source, { file: "plasma.sl" })
- *     //    ^ a Program: encode() it, emit HLSL from it, hash it
+ *     //    ^ a Program: compile() it, emit HLSL from it, hash it
  *
  * The parser is not a second authoring surface with its own semantics. It
  * lowers through the EDSL, so a `.sl` file and the `sl.program(...)` an author

package/src/lang/lower.ts

@@ -15,8 +15,7 @@
  * existed. Reassignment is free; it is not a store.
  *
  * **`for` unrolls.** The bounds are constants, so the body is lowered once per
- * iteration with the counter substituted as a number. `sl.unrolled` records the
- * span so the instruction ceiling error can name the loop that spent it.
+ * iteration with the counter substituted as a number.
  *
  * **`if` becomes `select`.** Both sides are lowered and every local assigned in
  * either is selected at the join. A constant condition folds instead, which is
@@ -421,20 +420,19 @@ export function lower(checked: Checked, errors?: SLParseError[]): Program {
                         count++
                         if (count > MAX_UNROLL) {
                             fail(
-                                `this loop would unroll to more than ${MAX_UNROLL} iterations. There is ` +
-                                `no loop on either backend, so every iteration is emitted in full and ` +
-                                `the VM runs at most 256 instructions`,
+                                `this loop would unroll to more than ${MAX_UNROLL} iterations. A for ` +
+                                `loop unrolls at build time, so every iteration is written out in full`,
                                 s.pos,
                             )
                         }
                     }
-                    at(s.pos, () => sl.unrolled(count, () => {
+                    at(s.pos, () => {
                         for (let i = from; s.inclusive ? i <= to : i < to; i += step) {
                             const inner = new Scope(scope)
                             inner.declare(s.counter, { width: 1, value: i })
                             exec(s.body, inner, ret)
                         }
-                    }))
+                    })
                     break
                 }
                 default:
@@ -447,7 +445,7 @@ export function lower(checked: Checked, errors?: SLParseError[]): Program {
         if (typeof v !== "number") {
             fail(
                 `a for loop unrolls at build time, so its ${what} has to be a constant. This one is ` +
-                `computed while the shader runs, and neither backend has a loop to run it in`,
+                `computed while the shader runs`,
                 e.pos,
             )
         }
@@ -609,7 +607,7 @@ export function lower(checked: Checked, errors?: SLParseError[]): Program {
                 const v = lowerExpr(a, scope)
                 if (typeof v !== "number") {
                     fail(
-                        `sdf.${shape}'s shape parameters ride inside the instruction, so they have to ` +
+                        `sdf.${shape}'s shape parameters are part of the operation, so they have to ` +
                         `be constants. A size that changes belongs on the point: scale or offset it ` +
                         `before the call`,
                         a.pos,
@@ -730,8 +728,8 @@ const ARITH: Record<ArithOp, (a: number, b: number) => number> = {
     "-": (a, b) => a - b,
     "*": (a, b) => a * b,
     "/": (a, b) => a / b,
-    // JavaScript's % is the truncated remainder, which is what HLSL's fmod is
-    // and what the VM's OP_MOD implements. Folding it in JS is the same answer.
+    // JavaScript's % is the truncated remainder, which is what HLSL's fmod is.
+    // Folding it in JS is the same answer.
     "%": (a, b) => a % b,
 }
 

package/src/lang/parser.ts

@@ -344,8 +344,8 @@ class Parser {
         if (t.text === "for") return this.parseFor()
         if (t.text === "while" || t.text === "do") {
             this.fail(
-                `there is no ${t.text} loop: the VM has no branches, so a loop has to unroll, and ` +
-                `only a for loop with constant bounds can. See a for loop`,
+                `there is no ${t.text} loop: a loop unrolls at build time, and only a for loop ` +
+                `with constant bounds can. See a for loop`,
                 t,
             )
         }

package/src/lang/prelude.ts

@@ -7,8 +7,8 @@
  *
  * ADDING TO IT COSTS A FUNCTION AND A TEST, NOT AN OPCODE IN THREE PLACES. That
  * is the whole argument for having a text language with inlining functions: a
- * library entry is source, so it lands in the VM, in generated HLSL and in the
- * hash by being ordinary code, and neither backend learns anything new.
+ * library entry is source, so it lands in every emitter's output and in the
+ * hash by being ordinary code, and no backend learns anything new.
  *
  * WHY THE SOURCE IS A STRING AND NOT A FILE. `onejs-sl` ships raw TypeScript
  * and runs inside a browser worker on play.onejs.com, where

package/src/ops.ts

@@ -1,10 +1,9 @@
 /**
  * The shader language opcode table.
  *
- * Phase 1 of `Specs/SHADER_LANG.md`. This is the contract three things will
- * share: the encoder that packs a program into a texture, the VM shader that
- * evaluates it, and the HLSL emitter that prints it. Two of those do not exist
- * yet, which is exactly why the numbering is fixed now rather than later.
+ * Phase 1 of `Specs/SHADER_LANG.md`. The numbers are in every program's hash
+ * and in its JSON, so an opcode keeps its number for good, and one that goes
+ * leaves its number unused.
  *
  * Numbered in families with gaps, the convention `fx/ops.ts` set, so a reader
  * can tell what an opcode is from its value:
@@ -23,31 +22,22 @@
  */
 
 /**
- * The newest VM encoding this encoder writes. The VM accepts 1..its own and
- * refuses newer, where there is a VM: a WebGL player draws compiled and never
- * reads the buffer.
+ * How many uniforms and textures one program may declare: the language's caps,
+ * for a host to read.
  *
- * A payload records the LOWEST version that can run it (`Encoded.wire`), not
- * this: a program that uses nothing new stays 1, so a new bundle still runs on
- * an older Play container, and only a program that needs a newer instruction
- * is refused by an older one rather than drawn wrong.
+ * They are what OneJS draws a program with. It keeps a program's uniforms in
+ * 16 slots in the editor, a native player and a browser alike
+ * (`SLProgramBridge.MaxUniforms`, the web frame's `sl_U`), and binds four
+ * textures in the editor and a native player (`_Tex0` to `_Tex3`). A program
+ * past either has something with no slot of its own, which one host would drop
+ * and another would draw, so the parser and the builder both refuse it at the
+ * declaration, the parser with a file and a line. `Specs/SL_NEXT.md` section 8
+ * proposes raising both.
  */
-export const SL_WIRE_VERSION = 2
+export const UNIFORM_SLOTS = 16
+export const TEXTURE_SLOTS = 4
 
-/**
- * What the VM shader actually declares, and therefore what a program may use.
- *
- * `FxProgram.shader` has `float4 _Uniforms[16]` and four `sampler2D`s, and
- * `SLProgramBridge.cs` fills exactly those. Past either ceiling the VM does not
- * fail, it clamps: uniform 17 reads slot 15 and texture slot 4 samples `_Tex3`,
- * while the generated HLSL would declare both correctly. That is a silent
- * disagreement between the backends, so the text form reports it at the
- * declaration with a file and a line. See `Specs/SL_TEXT.md` 3.7.
- */
-export const VM_UNIFORMS = 16
-export const VM_TEXTURES = 4
-
-/** Input ids, fixed here because the shader switches on them. */
+/** Input ids, which the web emitter switches on. */
 export const INPUT_ID: Record<string, number> = {
     uv: 0, fragCoord: 1, resolution: 2, time: 3, aspect: 4,
 }
@@ -129,10 +119,7 @@ export const SLOP = {
     // made bright. imm.x carries the octave count, as FBM does.
     TURBULENCE: 133,
     RIDGED: 134,
-    // VM only: an SDF given a fifth or sixth parameter, which one instruction's
-    // four immediates and id cannot hold. The encoder makes it (`forVm`); the
-    // IR and every compiled backend only ever see SDF.
-    SDF_WIDE: 135,
+    // 135 was SDF_WIDE, the VM's form of an SDF with more than four parameters.
 
     // Sampling
     SAMPLE: 144,
@@ -142,7 +129,7 @@ export const SLOP = {
 export type SLOpCode = (typeof SLOP)[keyof typeof SLOP]
 
 /**
- * How many arguments each op takes, for validation and for the encoder.
+ * How many arguments each op takes, for validation.
  *
  * -1 means variadic: COMPOSE takes however many parts add up to its width, RAMP
  * takes a value plus its stops. Everything else is fixed, and a mismatch is a
@@ -170,7 +157,7 @@ export const SL_ARITY: Record<number, number> = {
     [SLOP.RAMP]: -1, [SLOP.HSV2RGB]: 1, [SLOP.RGB2HSV]: 1, [SLOP.LUMINANCE]: 1, [SLOP.TO_LINEAR]: 1,
 
     [SLOP.NOISE]: 1, [SLOP.SIMPLEX]: 1, [SLOP.FBM]: 1, [SLOP.SDF]: 1,
-    [SLOP.VORONOI]: 1, [SLOP.TURBULENCE]: 1, [SLOP.RIDGED]: 1, [SLOP.SDF_WIDE]: 2,
+    [SLOP.VORONOI]: 1, [SLOP.TURBULENCE]: 1, [SLOP.RIDGED]: 1,
 
     [SLOP.SAMPLE]: 1, [SLOP.SAMPLE_LOD]: 2,
 }
@@ -180,18 +167,10 @@ export const SL_NAME: Record<number, string> = Object.fromEntries(
     Object.entries(SLOP).map(([name, code]) => [code, name.toLowerCase()]),
 )
 
-export const FIRST_ARITHMETIC = 16
-export const FIRST_MATHS = 48
-export const FIRST_GEOMETRY = 80
-export const FIRST_INTERPOLATE = 96
-export const FIRST_COLOUR = 112
-export const FIRST_PROCEDURAL = 128
-export const FIRST_SAMPLING = 144
+const FIRST_SAMPLING = 144
 
 /**
- * Ops that read a texture. Sampler slots are the one resource ceiling neither
- * backend can widen (16 in a fragment shader on WebGL2), so these are counted
- * at record time.
+ * Ops that read a texture.
  */
 export function isSampling(op: number): boolean {
     return op >= FIRST_SAMPLING
@@ -285,7 +264,6 @@ export const SL_HLSL: Record<number, SLSurface> = {
     [SLOP.VORONOI]: { call: "voronoi" },
     [SLOP.TURBULENCE]: { call: "turbulence" },
     [SLOP.RIDGED]: { call: "ridged" },
-    [SLOP.SDF_WIDE]: { syntax: "sdf.<shape>(p, ...) given a fifth or sixth parameter" },
 
     [SLOP.SAMPLE]: { call: "tex2D" },
     [SLOP.SAMPLE_LOD]: { call: "tex2Dlod" },
@@ -296,16 +274,15 @@ export const SL_HLSL: Record<number, SLSurface> = {
  *
  * Numbered so the families stay in order, and refused at the surface until
  * somebody writes both halves. A program reaching one would render as whatever
- * the VM's dispatch falls through to and fail outright in the HLSL emitter,
- * which is the silent-disagreement failure this design exists to prevent, so
- * the parser names them rather than treating them as unknown identifiers.
+ * nothing: the emitters have no case for them. So the parser names them rather
+ * than treating them as unknown identifiers.
  *
  * `REMAP` is here because the opcode is unimplemented; the SURFACE `remap` is a
  * macro over arithmetic and works everywhere.
  */
 export const SL_UNIMPLEMENTED: Record<number, string> = {
-    [SLOP.RGB2HSV]: "neither the VM shader nor the HLSL emitter has a case for it",
-    [SLOP.SAMPLE_LOD]: "the VM samples without an explicit LOD; use tex2D",
+    [SLOP.RGB2HSV]: "no backend has a case for it yet",
+    [SLOP.SAMPLE_LOD]: "no backend samples at an explicit LOD yet; use tex2D",
     [SLOP.REMAP]: "the surface form is a macro over arithmetic, so the opcode is unused",
 }
 

package/src/serial.ts

@@ -9,7 +9,7 @@
  * older one is migrated to this one and rehashed under it.
  */
 import {
-    INPUTS, SLError, SL_IR_VERSION, TYPE, controlOf, controlProblem, hashProgram,
+    INPUTS, SLError, SL_IR_VERSION, TYPE, checkCaps, controlOf, controlProblem, hashProgram,
     type NodeRef, type Program, type SLNode, type SLType, type TextureDecl, type UniformDecl,
 } from "./ir"
 import { SL_ARITY, SL_NAME } from "./ops"
@@ -44,6 +44,7 @@ export function fromJSON(json: unknown): Program {
     if (nodes[result!]!.type !== TYPE.VEC4) fail("its result is not a float4")
     const uniforms = (j.uniforms ?? []).map(uniform)
     const textures = (j.textures ?? []).map(texture)
+    checkCaps({ uniforms, textures })
     for (const n of nodes) {
         if (n.k === "uniform" && n.slot >= uniforms.length) fail(`a node reads uniform slot ${n.slot}, which is not declared`)
     }
@@ -54,7 +55,7 @@ export function fromJSON(json: unknown): Program {
     if (v === SL_IR_VERSION && j.hash !== undefined && j.hash !== hash) {
         fail(`its hash ${j.hash} does not match its nodes (${hash}); it was changed after it was written`)
     }
-    return { version: SL_IR_VERSION, nodes, result: result!, uniforms, textures, hash, loops: [] }
+    return { version: SL_IR_VERSION, nodes, result: result!, uniforms, textures, hash }
 }
 
 function node(n: unknown, i: number): SLNode {

package/src/sl.ts

@@ -207,7 +207,7 @@ function align2(a: Val, o: Num): [NodeRef, NodeRef] {
  * right for two operands because `bin` takes the max itself; the three and four
  * operand ops used to take the width from one chosen operand, so
  * `mix(0, aVec3, t)` produced a node typed float that held three components.
- * The VM keeps every value in a float4 register and never noticed, while the
+ * The VM, which kept every value in a float4 register, never noticed, while the
  * HLSL emitter declared `float` and truncated, so the two backends rendered
  * different pictures from one program. Anything component wise with more than
  * two operands goes through here.
@@ -294,7 +294,6 @@ export function program(fn: (inputs: ProgramInputs) => Vec4): Program {
             uniforms: b.uniforms.slice(),
             textures: b.textures.slice(),
             hash: hashProgram(nodes, out.ref, b.uniforms, b.textures),
-            loops: b.loops.slice(),
         }
     } finally {
         current = null
@@ -312,23 +311,14 @@ function compose(width: SLType, parts: Num[]): Val {
     // Wide parts are SPLIT into their components here, so COMPOSE only ever
     // sees scalars.
     //
-    // The VM keeps every value in a float4 register and took the x of each
-    // operand, which silently dropped everything after the first component:
-    // vec4(uv, 0, 1) rendered (uv.x, 0, 1, 0) instead of (uv.x, uv.y, 0, 1).
-    // Teaching the shader each part's width would need widths in an encoding
-    // that has no room for them, and would put the complexity in the half that
-    // is hardest to test. Splitting at record time costs a few extra swizzle
-    // nodes, which the register allocator reclaims immediately, and leaves the
-    // VM's COMPOSE trivially correct.
+    // The VM (removed in 0.3.0) took the x of each operand, which dropped
+    // everything after the first component: vec4(uv, 0, 1) rendered
+    // (uv.x, 0, 1, 0). Splitting at record time costs a few extra swizzle
+    // nodes and keeps every emitter's COMPOSE trivial.
     // A constructor of literals is ONE constant, not a COMPOSE of four.
     //
-    // `vec4(0.1, 0.2, 0.3, 0.4)` was five instructions holding four registers
-    // at once, because every part became its own CONST and COMPOSE kept them
-    // all live. The IR has always been able to say it in one node: a const
-    // carries up to four components. A two stop `ramp` used five of the eight
-    // registers on nothing but its own stop colours, which put the language's
-    // headline colour tool within one or two registers of unusable in any
-    // program that also did something.
+    // Every part as its own CONST, joined by a COMPOSE, is five nodes where the
+    // IR can say it in one: a const carries up to four components.
     if (parts.length === width && parts.every((p) => typeof p === "number")) {
         return mk(b, b.constant(parts as number[]), width)
     }
@@ -425,9 +415,8 @@ export function hsv2rgb(c: Vec3): Vec3 {
 /**
  * Cross and reflect, both vec3 only.
  *
- * The VM evaluates them as `cross(a.xyz, b.xyz)`, so a vec2 or vec4 would mean
- * one thing in a compiled build and another in the interpreter. Refusing the
- * other widths here is what keeps the two honest.
+ * Refusing the other widths here keeps every backend drawing the same thing,
+ * rather than each deciding what a vec2 or vec4 cross product means.
  */
 export function cross(a: Vec3, b: Vec3): Vec3 {
     if (a.width !== TYPE.VEC3 || b.width !== TYPE.VEC3) {
@@ -452,7 +441,7 @@ export function reflect(incident: Vec3, normal: Vec3): Vec3 {
  *
  * A MACRO, like `ramp`, and for the same reason: it expands into arithmetic
  * both backends already have, so it needs no opcode, no second implementation
- * in the emitter and no VM case. `SLOP.REMAP` stays a reserved number.
+ * in the emitters. `SLOP.REMAP` stays a reserved number.
  *
  * Unclamped on purpose, which is what HLSL authors expect of the one liner they
  * would otherwise write; wrap it in `saturate` when the ends matter.
@@ -495,11 +484,10 @@ export function select(cond: Num, whenTrue: Num, whenFalse: Num): Val {
     const t = typeof whenTrue === "number" ? float(whenTrue) : whenTrue
     const f = typeof whenFalse === "number" ? float(whenFalse) : whenFalse
     // The condition is widened with the branches, not left at its own width.
-    // A register is a float4 whatever it holds, so a scalar condition sits
-    // there as (c, 0, 0, 0) and the VM's `step(0.5, cond)` answered 0 for
-    // components y, z and w, while the HLSL backend broadcasts a scalar
-    // itself. The two DISAGREED on every vector valued select, which is the one
-    // failure this design cannot tolerate.
+    // The VM (removed in 0.3.0) held a scalar condition as (c, 0, 0, 0) and
+    // answered 0 for components y, z and w, while HLSL broadcasts a scalar
+    // itself; the two disagreed on every vector valued select. Widening here
+    // keeps every emitter's SELECT the same simple form.
     const { refs, width } = alignN([c, t, f])
     return mk(b, b.call(SLOP.SELECT, width, refs), width)
 }
@@ -507,8 +495,8 @@ export function select(cond: Num, whenTrue: Num, whenFalse: Num): Val {
 /**
  * The interpolant is broadcast to the operand width before it crosses.
  *
- * A register is a float4 whatever it holds, so a scalar `t` sits there as
- * (t, 0, 0, 0) and the shader's lerp ran per component against those zeros:
+ * The VM (removed in 0.3.0) held a scalar `t` as (t, 0, 0, 0) and its lerp
+ * ran per component against those zeros:
  * a black to white ramp at its midpoint rendered (0.5, 0, 0, 1) instead of
  * grey. Broadcasting here rather than in the shader keeps `t` free to be a
  * genuine per component vector when an author wants one.
@@ -597,13 +585,9 @@ export function parseColor(hex: string): [number, number, number, number] {
 export function ramp(t: Num, stops: Array<string | [number, number, number, number]>): Vec4 {
     if (stops.length < 2) throw new SLError(`a ramp needs at least 2 stops, got ${stops.length}`)
     const tv = (typeof t === "number" ? float(t) : t).saturate()
-    // Each stop is built IMMEDIATELY BEFORE the mix that consumes it, not all
-    // of them up front. The graph is identical either way and so is the hash,
-    // which is a Merkle hash over the shape and not over storage order, but the
-    // register allocator walks the array: built up front, every stop stayed
-    // live until the last mix, and a four stop ramp reserved four of the VM's
-    // eight registers before the program did anything. That put the language's
-    // headline colour tool a couple of registers from unusable.
+    // Each stop is built immediately before the mix that consumes it. The graph
+    // and the hash are the same either way (the hash is over the shape, not the
+    // storage order); the order only mattered to the VM's register allocator.
     const colourAt = (i: number) => {
         const v = typeof stops[i] === "string" ? parseColor(stops[i] as string) : (stops[i] as number[])
         return vec4(v[0], v[1], v[2], v[3])
@@ -733,34 +717,13 @@ export function texture(name: string): Texture {
  *
  * Honest about what it is: a macro, not a loop. It covers fbm, layered noise and
  * small iterated distance fields, which is most of what 2D shaders loop for. A
- * data dependent loop is out of scope, because in the VM it would need a nested
- * bounded loop with a dynamic trip count while codegen would handle it fine, and
- * the two backends agreeing is the property this whole design protects.
+ * loop with a runtime count is `Specs/SL_NEXT.md` proposal 3b.
  */
 export function repeat<T extends Val>(n: number, body: (i: number, acc: T) => T, seed: T): T {
     if (!Number.isInteger(n) || n < 0 || n > 64) {
         throw new SLError(`repeat count must be a whole number from 0 to 64, got ${n}`)
     }
-    return unrolled(n, () => {
-        let acc = seed
-        for (let i = 0; i < n; i++) acc = body(i, acc)
-        return acc
-    })
-}
-
-/**
- * Records the nodes a body produced as one unrolled span.
- *
- * Diagnostic only: the instruction ceiling error uses the span to say which
- * loop spent the budget, so the fix reads as "lower this count" rather than
- * "fewer instructions". `repeat` is the EDSL's form of it and the text
- * language's `for` is the other, and neither should be reaching into the
- * Builder to push a span itself.
- */
-export function unrolled<T>(count: number, body: () => T): T {
-    const b = ctx()
-    const start = b.nodes.length
-    const out = body()
-    b.loops.push({ count, start, end: b.nodes.length })
-    return out
+    let acc = seed
+    for (let i = 0; i < n; i++) acc = body(i, acc)
+    return acc
 }

package/src/web.ts

@@ -2,11 +2,10 @@
  * The web backends: prints a program as GLSL ES 3.00 or WGSL, for a browser to
  * compile at runtime on Unity's own graphics device.
  *
- * Unity cannot compile a shader in a built game, which is why the VM exists.
- * A browser can, and the Play container runs on WebGPU with WebGL2 behind it,
- * so a program becomes WGSL on one and GLSL ES on the other and runs compiled:
- * no register budget, no interpreter, and on the spike's measurements 100 to
- * 600 times cheaper per pixel. The host that compiles and draws these lives in
+ * Unity cannot compile a shader in a built game, so a native build ships the
+ * shaders the editor generated. A browser can compile, and the Play container
+ * runs on WebGPU with WebGL2 behind it, so a program becomes WGSL on one and
+ * GLSL ES on the other. The host that compiles and draws these lives in
  * OneJS (`Plugins/WebGL/OneJSSLWeb.jslib`); this file only prints them.
  *
  * Structurally the HLSL emitter again: one local per reachable node, in order,
@@ -29,12 +28,12 @@ import { SLError, TYPE, type Program, type SLNode, type SLType } from "./ir"
 import { libClosure, libIndex, LIB_FUNCTIONS, SDF_CALLS } from "./lib"
 import { LIB_GLSL } from "./lib/glsl"
 import { LIB_WGSL } from "./lib/wgsl"
-import { INPUT_ID, SLOP, VM_UNIFORMS } from "./ops"
+import { INPUT_ID, SLOP, UNIFORM_SLOTS } from "./ops"
 
 export type WebLanguage = "glsl" | "wgsl"
 
 /** Uniform slots the host always provides, so every program shares one layout. */
-export const WEB_UNIFORM_SLOTS = VM_UNIFORMS
+export const WEB_UNIFORM_SLOTS = UNIFORM_SLOTS
 
 export function emitGLSL(p: Program): string {
     return emitWeb(p, "glsl")
@@ -159,7 +158,7 @@ function emitWeb(p: Program, lang: WebLanguage): string {
             case SLOP.MIX: return `mix(${s[0]}, ${s[1]}, ${s[2]})`
             case SLOP.STEP: return `step(${s[0]}, ${s[1]})`
             case SLOP.SMOOTHSTEP: smoothsteps.add(t); return `sl_smoothstep${t}(${s[0]}, ${s[1]}, ${s[2]})`
-            // As the VM and the HLSL emitter do it: branchless, so every
+            // As the HLSL emitter does it: branchless, so every
             // backend agrees on the edge value.
             case SLOP.SELECT: {
                 const c = typeOf(n.args[0])
@@ -182,7 +181,7 @@ function emitWeb(p: Program, lang: WebLanguage): string {
             default:
                 throw new SLError(
                     `the ${lang.toUpperCase()} emitter has no case for opcode ${n.op}. A program using it would ` +
-                    `differ between the VM and a compiled build, which is the one failure this design cannot tolerate.`,
+                    `differ between a browser and a Unity build, which is the one failure this design cannot tolerate.`,
                 )
         }