onejs-sl 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 0.3.0
+
+The VM is gone: every program is compiled, so there is no instruction buffer, wire version or VM limit left to import. A host on `compile` changes nothing; one still importing `onejs-sl/vm` or `onejs-sl/limits` moves to `onejs-sl/compile` and `onejs-sl/core`.
+
+- `onejs-sl/vm`, `onejs-sl/limits`, `encode`, `forVm`, `vmFit` and `SL_WIRE_VERSION` are removed
+- `VM_UNIFORMS` and `VM_TEXTURES` are removed; `UNIFORM_SLOTS` and `TEXTURE_SLOTS` in `onejs-sl/core` are the same numbers
+- `MAX_TEXTURES` is removed
+- `Program.loops`, `LoopSpan` and `sl.unrolled` are removed
+- `fromJSON` refuses opcode 135, which only the VM's encoder wrote
+- No error, doc or generated shader comment names the VM
+
+## 0.2.1
+
+A program built in code or read from JSON is refused past 16 uniforms or 4 textures, as a `.sl` file already was, instead of compiling and then drawing differently on different hosts. A host can read both caps.
+
+### Fixed
+
+- 0.2.0 regression: `compile()` dropped `encode()`'s texture check, so a program built in code with a fifth texture compiled and then sampled nothing in the editor and a native player
+
+### Changed
+
+- `sl.texture` and `sl.uniform` refuse past the caps where they are declared, in the parser's words
+- `compile` and `fromJSON` refuse a program past either cap, however it was made
+- `onejs-sl/core` exports `UNIFORM_SLOTS` (16) and `TEXTURE_SLOTS` (4), which the parser and the builder both read
+- `MAX_TEXTURES` is a deprecated alias of `TEXTURE_SLOTS`, so 4 rather than 15
+- `VM_UNIFORMS` and `VM_TEXTURES` are the same numbers, and go with the VM
+- The parser's cap messages give OneJS's slots as the reason
+
 ## 0.2.0
 
 `compile()` replaces `encode()` for every host that draws compiled: it gives a program's hash, names, defaults and sources with no VM buffer and no budget, so a long program or one with many values at once compiles. Program hashes do not change.

package/README.md

@@ -3,8 +3,7 @@
 The OneJS shader language: a small typed language for per pixel programs. A
 program is written as a `.sl` file (HLSL text) or with the TypeScript form, and
 recorded as one portable IR, a flat typed graph with a hash. The package emits
-that IR as the buffer OneJS's VM evaluates, a Unity ShaderLab shader, WGSL and
-GLSL ES.
+that IR as a Unity ShaderLab shader, WGSL and GLSL ES.
 
 It is the compiler [OneJS](https://onejs.com) uses, taken out of `onejs-unity`
 so a host without Unity can run it too. `onejs-unity/sl` and
@@ -36,11 +35,9 @@ only what it calls.
 | Entry | Contents |
 |---|---|
 | `onejs-sl` | `parse` and `analyze`, `diagnose` (every error in a file, not just the first), `classify` (every token with its class, comments kept, never throws), `fromGLSL` (a pasted Shadertoy or WebGL shader as a `.sl` file, with notes on what did not carry over), the TypeScript form `sl`, the IR types, `SL_IR_VERSION`, `toJSON`/`fromJSON`, `SLParseError` (file, line, column, offset, length, the bare `text`, and a `fix` where one is certain) |
-| `onejs-sl/core` | the same without the parser: what a game needs at run time |
+| `onejs-sl/core` | the same without the parser: what a game needs at run time. Also the caps on one program, `UNIFORM_SLOTS` (16) and `TEXTURE_SLOTS` (4), which the parser and the builder enforce and a host can read |
 | `onejs-sl/tables` | `BUILTINS`, `SL_HLSL`, `INPUTS`, `SL_SDF_SHAPES`, `SL_SDF_PARAMS`, `SL_KEYWORDS`, `SL_TYPES`, `TYPE_WIDTH`, `PRELUDE_NAMES`: what completion and highlighting read. `BUILTIN_PARAMS`, `SL_SDF_PARAM_NAMES` and `LIB_SIGNATURES` name every parameter, so an editor can show `lerp(x, y, s)`, and `BUILTIN_DOCS`, `INPUT_DOCS` and `PRELUDE_DOCS` give each a line for its tooltip |
 | `onejs-sl/compile` | `compile(program)`: what a host draws a program with. Its hash, its uniform and texture names in slot order, their defaults, and `hlsl`, `wgsl` and `glsl` as lazy getters. No budget |
-| `onejs-sl/limits` | `vmFit(program)`: whether the VM runs it, and why not. The VM's, until it is deleted |
-| `onejs-sl/vm` | `encode`, `SL_WIRE_VERSION`: `compile` plus the VM's buffer. The VM's, until it is deleted |
 | `onejs-sl/emit/hlsl-body` | `emitBody`: a program as a function body for a host's own frame; `emitLibrary`: the library functions it calls |
 | `onejs-sl/emit/unity` | `emitShader`: the `.shader` a Unity editor generates, a frame over `emitBody` |
 | `onejs-sl/emit/web` | `emitWGSL`, `emitGLSL`: OneJS's web frame |
@@ -91,7 +88,7 @@ by `npm run lib`, and nobody edits the copies:
 
 - **OneJS's `.cginc` files** (`SDF2D`, `Noise2D`, `SLCommon` in
   `Resources/OneJS/`) are the source with an include guard and a generated
-  header around it. The VM, the generated Unity shaders and `fx` include them.
+  header around it. The generated Unity shaders and `fx` include them.
   `npm run lib` writes them when the package sits in the OneJS container.
 - **`src/lib/`**: `table.ts` (every function, its signature, what it calls, and
   the shape table read from `sl_sdfDistance`'s switch), and the text of each
@@ -169,7 +166,7 @@ and QuickJS (Magerie). Two checks hold it to that:
 - `npm run test:quickjs` bundles `quickjs/corpus.ts` as one ES2020 IIFE, the
   way Magerie bundles a script, runs it in QuickJS-ng and in a bare Node
   context, and fails unless the two results agree byte for byte. The corpus
-  parses, encodes, fits and emits every program in `corpus/`, every
+  parses, compiles and emits every program in `corpus/`, every
   shape at its full parameter count, and the error paths. `npm test` runs it
   after vitest.
 
@@ -206,15 +203,14 @@ container this package is checked out at `JSModules/onejs-sl`, and
 ## The one idea
 
 **One authoring surface, one IR, several backends.** Unity cannot compile a
-shader at runtime in a player build, on any graphics API, so the first backend
-made a program data that a fixed shader evaluates: a VM. An editor does compile
-shaders, at build time, so the second prints HLSL for it.
+shader at runtime in a player build, on any graphics API, but an editor
+compiles shaders at build time, so `hlsl.ts` prints HLSL for it and the build
+ships the result.
 
 So the same source draws compiled from generated HLSL in the editor and in a
-native player, with no edit in between, and the VM stays behind a switch: OneJS
-leaves it out unless a project defines `ONEJS_SL_VM`. `compile.ts` gives a host
-everything it draws with and no VM buffer; `encode.ts` adds the buffer for
-`FxProgram.shader`, and goes with the VM. `hlsl.ts` feeds OneJS's
+native player, with no edit in between. `compile.ts` gives a host everything it
+draws with. (Until 0.3.0 a VM, one fixed shader evaluating a program as data,
+drew what had no shader yet; OneJS 3.8 deleted it.) `hlsl.ts` feeds OneJS's
 `Editor/SLShaderGenerator.cs`. Nobody writes a manifest for it: an editor that
 draws a program asks the compiled program for its
 `hlsl` (a lazy getter, never read in Play), records it into
@@ -229,7 +225,7 @@ as GLSL ES 3.00 (carrying the library functions it calls, translated from
 `Plugins/WebGL/OneJSSLWeb.jslib` compiles whichever one Unity's device speaks
 and draws it into the element's target. A `.sl` import carries both strings,
 printed at build time; a `compile()` result has them as lazy getters, like
-`hlsl`. A WebGL player has no VM: the element draws nothing until the compiled
+`hlsl`. The element draws nothing until the compiled
 program is ready, and nothing after a compile error, which the page reports.
 The host contract (the frame block, the
 16 uniform slots, one binding pair per sampled texture) is written out at the
@@ -237,7 +233,7 @@ top of `web.ts`.
 
 The emitters match the HLSL emitter's semantics rather than each language's
 own: `%` truncates like `fmod`, `pow` takes `abs` of its base, `asin` and
-`acos` clamp, `log` and `sqrt` guard their argument, a select is the VM's
+`acos` clamp, `log` and `sqrt` guard their argument, a select is a
 branchless `lerp`. `web.test.ts` checks the structure (every shape, every
 opcode, the library order); whether the output matches the goldens is
 measured in a browser, through the real element, by `Tools/sl-web-parity` in
@@ -274,7 +270,7 @@ references, and writing it out long hand three times costs exactly the same,
 because nodes are interned as they are built.
 
 That reasoning is why the parser, when it came, cost only a parser: it emits
-this same IR, so it inherited the encoder, the emitter, the hash and every test
+this same IR, so it inherited the emitters, the hash and every test
 that runs on a program.
 
 ## What is checked, and when
@@ -289,11 +285,12 @@ at module load, not at draw time:
 | A program returning something other than a `vec4` | "a program must return a vec4. Wrap it: sl.vec4(value, 1)" |
 | `vec4` given the wrong number of parts | "vec4 needs 4 components, got 3" |
 | One uniform name at two widths | "declared as both a float and a vec4" |
-| More than 15 textures | Names the limit and why it cannot be widened |
+| More than 16 uniforms or 4 textures | "this program declares 5 textures and a program may sample 4", the parser's words |
 | A value borrowed from another program | "a value from another program cannot be used in this one" |
 
-The texture ceiling is the fragment shader's sampler slots on the WebGL2
-baseline, which is the one resource neither backend can widen.
+The caps are `UNIFORM_SLOTS` and `TEXTURE_SLOTS`: what OneJS binds to one
+program. `compile` and `fromJSON` hold a program to them too, however it was
+made.
 
 ## The hash is the fragile part
 
@@ -323,20 +320,9 @@ refuses a newer one with a message naming both.
   `fromJSON` (`serial.ts`) are the IR as JSON for a host that stores programs;
   `fromJSON` checks everything an emitter relies on, refuses a newer version,
   and migrates an older one.
-- **`SL_WIRE_VERSION`** (`ops.ts`) is the newest VM encoding, and
-  `SLProgramBridge.WireVersion` in OneJS must match it (a container test
-  compares the two). `Encoded.wire`, and the `wire` in a `.sl` import, is the
-  LOWEST version that can run that program, so a program using nothing new
-  stays 1 and still runs on an older Play container. The VM refuses a newer
-  one, only where the VM runs; a WebGL player draws compiled and never reads
-  the buffer.
-
-IR 2 and wire 2 came with #129. A shape takes as many parameters as it reads
+IR 2 came with #129. A shape takes as many parameters as it reads
 (`SL_SDF_PARAMS`, six at most, and never fewer than four accepted), where it
-used to take four and lose the rest. One instruction holds a shape id and four
-immediates, so the encoder's `forVm` turns a shape given a fifth or sixth into
-`SDF_WIDE`, which reads the remaining four from a constant register. Only the
-VM sees it, and only those programs are wire 2.
+used to take four and lose the rest.
 
 ## Control flow
 
@@ -346,13 +332,10 @@ unrolls at record time because `n` is a JavaScript number.
 
 `repeat` is honest about being a macro rather than 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: the VM 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 the whole design protects.
-Because it unrolls, the count multiplies the body's operation count. `compile`
-has no ceiling, so a long program costs what it costs, as any shader does;
-`corpus/long.sl` is over a thousand operations. `encode` still refuses past the
-VM's 256, and names any `repeat` that fills a quarter of that.
+shaders loop for. A loop with a runtime count is `Specs/SL_NEXT.md` proposal
+3b. Because it unrolls, the count multiplies the body's operation count.
+`compile` has no ceiling, so a long program costs what it costs, as any shader
+does; `corpus/long.sl` is over a thousand operations.
 
 Every loop that reaches a GPU is therefore bounded by a constant: `repeat` is
 unrolled, fbm's octaves are a constant 1 to 4, the helper loops in the noise
@@ -364,8 +347,8 @@ reset takes the whole page's device, Unity's included.
 ## See also
 
 - `Specs/SHADER_LANG.md` in the OneJS container, sections 3 and 4, and section 5.4 for the Phase 0
-  measurements that decided the VM's shape
-- `Tools/shader-vm-spike/`, the harness behind those numbers
+  measurements that decided the VM's shape; the harness behind those numbers,
+  `Tools/shader-vm-spike/`, is in the container's history at `afd2535`
 - `onejs-unity`'s `fx`, the image pipeline this becomes a source and an operand for
 
 ## What a program is given

package/goldens/goldens.json

@@ -1,6 +1,6 @@
 {
  "generatedBy": "onejs-sl goldens/run.mjs",
- "package": "0.2.0",
+ "package": "0.3.0",
  "ir": 2,
  "target": "rgba8unorm-srgb: straight alpha, 8 bit, sRGB encoded, the stored bytes of a Linear OneJS game's element",
  "size": [

package/lib/common.hlsl

@@ -1,7 +1,7 @@
 // Helpers shared by EVERY shader language backend.
 //
-// The VM (OneJS/FxProgram.shader) includes this as SLCommon.cginc, and every
-// shader generated from a program by the HLSL emitter includes it too. The web
+// Every shader generated from a program by the HLSL emitter includes this as
+// SLCommon.cginc. The web
 // emitters and a host's own frame (`emitBody`) get it translated, by
 // `lib/translate.ts`, from this one text. That sharing is the whole reason this
 // file exists: the backends have to agree, and the fastest way to make them
@@ -134,10 +134,9 @@ float sl_luminance(float3 c) { return dot(c, float3(0.2126, 0.7152, 0.0722)); }
 // In a Gamma project the written value is already right. The float4 form keeps
 // alpha, which is coverage rather than light. Mirrors fxColorToWorking.
 //
-// Every width uses Unity's cubic approximation, lane by lane. The VM has one
-// TO_LINEAR for all widths (its registers are float4, so it converts .rgb),
-// and a scalar or float2 on the exact curve here drew up to 5/255 apart from
-// it in the dark range: the editor and a player disagreed.
+// Every width uses Unity's cubic approximation, lane by lane. A scalar or
+// float2 on the exact curve once drew up to 5/255 apart from the float3 form
+// in the dark range.
 //
 // The curve is Unity's GammaToLinearSpace, written out here so that a target
 // without UnityCG.cginc has it too. The switch below is the one piece of

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "onejs-sl",
-  "version": "0.2.0",
-  "description": "The OneJS shader language: a small typed language for per pixel programs, compiled to a portable IR and emitted as HLSL, WGSL, GLSL ES or a VM buffer",
+  "version": "0.3.0",
+  "description": "The OneJS shader language: a small typed language for per pixel programs, compiled to a portable IR and emitted as HLSL, WGSL or GLSL ES",
   "main": "src/index.ts",
   "types": "src/index.ts",
   "exports": {
@@ -9,8 +9,6 @@
     "./core": "./src/core.ts",
     "./compile": "./src/compile.ts",
     "./tables": "./src/tables.ts",
-    "./limits": "./src/limits.ts",
-    "./vm": "./src/vm.ts",
     "./emit/hlsl-body": "./src/emit/hlsl-body.ts",
     "./emit/unity": "./src/emit/unity.ts",
     "./emit/web": "./src/emit/web.ts",

package/src/body.ts

@@ -43,7 +43,7 @@ export interface BodyTarget {
      *   an sRGB texture is decoded before it is filtered, as an sRGB sampler
      *   does; with `gamma`, rgb is as stored.
      * - **Filtered and wrapped by the host.** The body does neither. OneJS's
-     *   hosts, the generated shader, the VM and the web backends alike, use the
+     *   hosts, the generated shader and the web backends alike, use the
      *   bound texture's own filter and wrap modes, so a host that filters by
      *   hand draws the same picture by following the texture's settings.
      *
@@ -143,7 +143,7 @@ export function emitBody(p: Program, target: BodyTarget): Body {
             case SLOP.MUL: return `(${a[0]} * ${a[1]})`
             case SLOP.DIV: return `(${a[0]} / ${a[1]})`
             case SLOP.MOD: return `fmod(${s[0]}, ${s[1]})`
-            // abs on the base, matching the VM. pow of a negative base is
+            // abs on the base, matching the web emitters. pow of a negative base is
             // undefined in HLSL and the backends must be undefined in the same
             // direction.
             case SLOP.POW: return `pow(abs(${s[0]}), ${s[1]})`
@@ -170,8 +170,8 @@ export function emitBody(p: Program, target: BodyTarget): Body {
             case SLOP.CLAMP: return `clamp(${s[0]}, ${s[1]}, ${s[2]})`
             case SLOP.SATURATE: return `saturate(${a[0]})`
 
-            // Of a scalar, Metal's are ambiguous, so what the VM computes for one
-            // (its lanes past the width hold 0) is written out.
+            // Of a scalar, Metal's are ambiguous, so the scalar case is written
+            // out.
             case SLOP.LENGTH: return w0 === 1 ? `abs(${a[0]})` : `length(${a[0]})`
             case SLOP.DISTANCE: return w0 === 1 ? `abs(${a[0]} - ${a[1]})` : `distance(${a[0]}, ${a[1]})`
             case SLOP.DOT: return w0 === 1 ? `(${a[0]} * ${a[1]})` : `dot(${a[0]}, ${a[1]})`
@@ -184,7 +184,7 @@ export function emitBody(p: Program, target: BodyTarget): Body {
             case SLOP.MIX: return `lerp(${s[0]}, ${s[1]}, ${s[2]})`
             case SLOP.STEP: return `step(${s[0]}, ${s[1]})`
             case SLOP.SMOOTHSTEP: return `smoothstep(${s[0]}, ${s[1]}, ${s[2]})`
-            // Matches the VM exactly, branchlessly, rather than using an if.
+            // Branchless, as the web emitters do it, rather than using an if.
             // Two backends that pick differently here disagree on every edge
             // value.
             case SLOP.SELECT: return `lerp(${s[2]}, ${s[1]}, step(${k(0.5, t)}, ${s[0]}))`
@@ -211,7 +211,7 @@ export function emitBody(p: Program, target: BodyTarget): Body {
             default:
                 throw new SLError(
                     `the HLSL emitter has no case for opcode ${n.op}. A program using it would silently ` +
-                    `differ between the VM and a compiled build, which is the one failure this design ` +
+                    `differ between a Unity build and a browser, which is the one failure this design ` +
                     `cannot tolerate.`,
                 )
         }

package/src/compile.ts

@@ -6,13 +6,12 @@
  * editor to generate a shader from, WGSL and GLSL ES 3.00 for a browser to
  * compile on Unity's own device.
  *
- * There is no budget. `encode` refuses a program past the VM's 256
- * instructions or 8 registers, because the VM cannot run it; every backend
- * here is a real compiler, so a long program costs what it costs, as any
- * shader does. `Specs/SL_NEXT.md` section 0.5, step 3.
+ * There is no budget: every backend is a real compiler, so a long program
+ * costs what it costs, as any shader does. The caps on uniforms and textures
+ * are the only refusal (`checkCaps`).
  */
 
-import type { Program } from "./ir"
+import { checkCaps, type Program } from "./ir"
 import { emitShader } from "./hlsl"
 import { emitGLSL, emitWGSL } from "./web"
 import { uniformDefaults } from "./sl"
@@ -69,6 +68,7 @@ export interface Compiled {
 }
 
 export function compile(program: Program): Compiled {
+    checkCaps(program)
     const compiled = {
         hash: program.hash,
         // Slot order, which is declaration order: Builder.uniform pushes and

package/src/core.ts

@@ -10,13 +10,13 @@
 export * as sl from "./sl"
 export type { Float, Vec2, Vec3, Vec4, Num, ProgramInputs, Texture } from "./sl"
 export {
-    TYPE, INPUTS, MAX_TEXTURES, MAX_NODES, SLError, hashProgram, widthName, SL_IR_VERSION, inputsUsed,
+    TYPE, INPUTS, MAX_NODES, SLError, hashProgram, widthName, SL_IR_VERSION, inputsUsed,
     CONTROL_FIELDS, controlProblem,
 } from "./ir"
 export type {
     SLType, InputName, NodeRef, SLNode, Program, UniformDecl, UniformControl, TextureDecl,
 } from "./ir"
-export { SLOP, SL_ARITY, SL_NAME, INPUT_ID, isSampling } from "./ops"
+export { SLOP, SL_ARITY, SL_NAME, INPUT_ID, isSampling, UNIFORM_SLOTS, TEXTURE_SLOTS } from "./ops"
 export type { SLOpCode } from "./ops"
 export { SL_SDF_SHAPES, SL_SDF_PARAMS } from "./shapes"
 export type { SlSdfKind } from "./shapes"

package/src/hlsl.ts

@@ -1,19 +1,12 @@
 /**
- * The second backend: prints a program as real HLSL, compiled at build time.
+ * The Unity backend: prints a program as real HLSL, compiled at build time.
  *
- * Phase 3 of `Specs/SHADER_LANG.md` section 6, and the half the whole design
- * exists for. Unity cannot compile a shader at runtime in a player build, so on
- * play.onejs.com a program has to be interpreted. Ejecting to a Unity project
- * does not change what the author wrote, it changes what is POSSIBLE, because
- * an editor compiles shaders at build time.
+ * Phase 3 of `Specs/SHADER_LANG.md` section 6. Unity cannot compile a shader
+ * at runtime in a player build, so the editor generates one per program and the
+ * build ships it; a browser compiles the web emitters' output instead
+ * (`web.ts`). The same source draws both ways with no edit in between.
  *
- * So the same source is interpreted in the browser and compiled after an eject,
- * with no edit in between. That is what stops "Play games eject cleanly" from
- * quietly acquiring an asterisk.
- *
- * WHY THIS IS THE EASY BACKEND. The VM keeps every value in a float4 register
- * and has to be told how wide each one really is. Here the IR's types become the
- * HLSL types directly, so `float2` is a `float2` and nothing needs padding or
+ * The IR's types become the HLSL types directly, so `float2` is a `float2` and nothing needs padding or
  * explaining. One local per node also gives common subexpression elimination for
  * free: a node is emitted once no matter how many nodes reference it.
  *
@@ -48,8 +41,8 @@ export interface EmitOptions {
  * Emits a complete `.shader` for a program.
  *
  * The shader's name carries the program hash, which is how the runtime finds it
- * again. If that link breaks, the runtime silently falls back to the VM and
- * nobody is told: correct output, quietly slow, no error. See `hashProgram`.
+ * again. If that link breaks, the program has no shader and draws nothing. See
+ * `hashProgram`.
  */
 export function emitShader(p: Program, options: EmitOptions = {}): string {
     const name = options.name ?? `Hidden/SLGenerated/${p.hash}`
@@ -99,7 +92,7 @@ ${props.join("\n")}
             #pragma fragment frag
             #pragma target 3.0
             #include "UnityCG.cginc"
-            // Shared with the VM, so both backends compute the same noise.
+            // Shared with the web frame, so every backend computes the same noise.
             #include "${include}"
 
 ${decls.join("\n")}
@@ -111,8 +104,8 @@ ${decls.join("\n")}
             {
                 v2f o;
                 o.pos = UnityObjectToClipPos(v.vertex);
-                // Origin corrected here exactly as the VM does it, so an ejected
-                // game is not upside down relative to the one on the site.
+                // Origin corrected here, so a Unity build is not upside down
+                // relative to the same program in a browser.
                 o.uv = float2(v.uv.x, lerp(v.uv.y, 1.0 - v.uv.y, _FlipY));
                 return o;
             }

package/src/index.ts

@@ -2,16 +2,14 @@
  * `onejs-sl`: the shader language, with no Unity in it.
  *
  * Source text or the TypeScript form in, a `Program` out: a flat typed graph
- * with a hash. Everything a host does with a program (run it on the VM, emit
- * HLSL, WGSL or GLSL ES) is a separate entry, so a host bundles only what it
+ * with a hash. Everything a host does with a program (emit HLSL, WGSL or GLSL
+ * ES) is a separate entry, so a host bundles only what it
  * calls:
  *
  *   onejs-sl             this: parse, diagnose, classify, fromGLSL, the TypeScript form, the IR, its JSON
  *   onejs-sl/core        the same without the parser, for a game at run time
  *   onejs-sl/tables      builtins, opcodes, inputs, shapes: what an editor reads
  *   onejs-sl/compile     what a host draws a program with, and no budget
- *   onejs-sl/limits      whether a program fits the VM, until the VM goes
- *   onejs-sl/vm          the VM encoder, until the VM goes
  *   onejs-sl/emit/unity  the ShaderLab shader a Unity editor generates
  *   onejs-sl/emit/web    WGSL and GLSL ES with OneJS's web frame
  *

package/src/ir.ts

@@ -1,9 +1,8 @@
 /**
- * The shader language IR: one graph, two consumers.
+ * The shader language IR: one graph, and every backend a function of it.
  *
- * Phase 1 of `Specs/SHADER_LANG.md` section 4. Everything the VM encoder and the
- * HLSL emitter do is a function of this shape, so it is the part worth getting
- * right before either exists.
+ * Phase 1 of `Specs/SHADER_LANG.md` section 4. Every emitter (HLSL, WGSL, GLSL
+ * ES) reads this shape and nothing else.
  *
  * Four properties are load bearing:
  *
@@ -12,7 +11,7 @@
  * produces the author facing type errors.
  *
  * **Nodes are a flat array in topological order.** A node refers to earlier
- * nodes by index only, never forwards, so an encoder can walk the array once and
+ * nodes by index only, never forwards, so an emitter can walk the array once and
  * emit in order. The hash deliberately does NOT depend on that order; see
  * `hashProgram`.
  *
@@ -21,12 +20,11 @@
  * pass. A tree would silently square the cost of the most natural way to write a
  * shader.
  *
- * **Nothing here knows about shaders.** No HLSL, no texture layout, no register
- * allocation. Those belong to the backends; this file is the contract between
+ * **Nothing here knows about shaders.** No HLSL, no texture layout, no binding. Those belong to the backends; this file is the contract between
  * them, and it is fully testable with no GPU.
  */
 
-import { SLOP, SL_ARITY, SL_NAME, type SLOpCode } from "./ops"
+import { SLOP, SL_ARITY, SL_NAME, TEXTURE_SLOTS, UNIFORM_SLOTS, type SLOpCode } from "./ops"
 
 /** Component count. The only notion of type the IR has. */
 export const TYPE = { FLOAT: 1, VEC2: 2, VEC3: 3, VEC4: 4 } as const
@@ -47,7 +45,7 @@ export type InputName = keyof typeof INPUTS
  * handed over by the host (`Specs/SL_NEXT.md` 6). Each read records the same
  * few nodes a program would if it wrote the expression out, and the builder's
  * hash consing makes every later read the same node. So there is no new
- * instruction, no VM or host change, and a program that never names one holds
+ * operation, no host change, and a program that never names one holds
  * no extra node, compiling to the bytes it always did.
  *
  *   texel     1 / resolution: one pixel, in uv
@@ -172,18 +170,6 @@ export interface TextureDecl {
     slot: number
 }
 
-/**
- * The nodes one `sl.repeat` call unrolled into, as the half open range
- * `[start, end)` of `nodes`. Diagnostic only: the instruction ceiling error
- * uses it to say which loop the operations came from, since a program that is
- * "too long" has usually been made so by one count.
- */
-export interface LoopSpan {
-    count: number
-    start: NodeRef
-    end: NodeRef
-}
-
 export interface Program {
     /** The `SL_IR_VERSION` this program's nodes mean what they mean under. */
     version: number
@@ -194,18 +180,37 @@ export interface Program {
     textures: TextureDecl[]
     /** Canonical, stable across machines. See `hashProgram`. */
     hash: string
-    /** Not part of the hash: it changes nothing about what the program computes. */
-    loops: LoopSpan[]
 }
 
 /**
- * Sampler slots in a fragment shader on the WebGL2 baseline, minus one for the
- * program texture itself. Exceeding it is refused when the program is written
- * rather than when it is drawn, with a message naming the limit.
+ * The refusals for a program past its caps, worded once for the parser (a
+ * `file`) and the builder (a `program`) so the two cannot drift apart.
  */
-export const MAX_TEXTURES = 15
+export function tooManyUniforms(declared: number, source: "file" | "program"): string {
+    return `this ${source} declares ${declared} uniforms and a program may hold ${UNIFORM_SLOTS}. ` +
+        `OneJS keeps a program's uniforms in ${UNIFORM_SLOTS} slots, so this one would have no ` +
+        `slot of its own; it is refused here rather than drawn wrong. Pack related values into ` +
+        `a ${source === "file" ? "float4" : "vec4"}.`
+}
+
+export function tooManyTextures(declared: number, source: "file" | "program"): string {
+    return `this ${source} declares ${declared} textures and a program may sample ${TEXTURE_SLOTS}. ` +
+        `OneJS binds ${TEXTURE_SLOTS} textures to a program in the editor and a native player, so ` +
+        `this one would sample nothing there while a browser drew it: two pictures from one ${source}.`
+}
+
+/**
+ * Refuses a finished program past either cap. The parser and the builder
+ * refuse at the declaration, where the message can point at it; this is for
+ * a program that arrived some other way, stored as JSON or put together by
+ * hand, and `compile` runs it so nothing reaches a host around it.
+ */
+export function checkCaps(p: Pick<Program, "uniforms" | "textures">): void {
+    if (p.uniforms.length > UNIFORM_SLOTS) throw new SLError(tooManyUniforms(p.uniforms.length, "program"))
+    if (p.textures.length > TEXTURE_SLOTS) throw new SLError(tooManyTextures(p.textures.length, "program"))
+}
 
-/** Instructions a single program may hold. Generous; the ceiling that matters is registers. */
+/** Operations a single program may hold. Generous: a guard against a runaway builder, not a budget. */
 export const MAX_NODES = 4096
 
 export class SLError extends Error {
@@ -226,7 +231,6 @@ export class Builder {
     readonly nodes: SLNode[] = []
     readonly uniforms: UniformDecl[] = []
     readonly textures: TextureDecl[] = []
-    readonly loops: LoopSpan[] = []
     private readonly interned = new Map<string, NodeRef>()
 
     add(node: SLNode): NodeRef {
@@ -288,6 +292,7 @@ export class Builder {
         const problem = controlProblem(type, value, control)
         if (problem !== null) throw new SLError(`uniform "${name}": ${problem.message}`)
         const slot = this.uniforms.length
+        if (slot >= UNIFORM_SLOTS) throw new SLError(tooManyUniforms(slot + 1, "program"))
         const decl: UniformDecl = { name, type, value: value.slice() }
         if (colour) decl.colour = true
         Object.assign(decl, controlOf(control))
@@ -298,12 +303,8 @@ export class Builder {
     texture(name: string): number {
         const existing = this.textures.findIndex((t) => t.name === name)
         if (existing >= 0) return this.textures[existing].slot
-        if (this.textures.length >= MAX_TEXTURES) {
-            throw new SLError(
-                `a program may sample at most ${MAX_TEXTURES} textures, and this one asks for ` +
-                `${this.textures.length + 1}. That ceiling is the fragment shader's sampler slots ` +
-                `on the WebGL2 baseline, so it cannot be widened.`,
-            )
+        if (this.textures.length >= TEXTURE_SLOTS) {
+            throw new SLError(tooManyTextures(this.textures.length + 1, "program"))
         }
         const slot = this.textures.length
         this.textures.push({ name, slot })
@@ -377,8 +378,7 @@ export function widthName(t: SLType): string {
  *
  * This is the link between a program and its compiled shader. If it differs
  * between the machine that generated the shader and the machine that runs it,
- * the runtime silently falls back to the VM and nobody is told, which is the
- * worst failure this design can have: correct output, quietly slow, no error.
+ * a native player finds no shader for the program and draws nothing.
  *
  * So it hashes the canonicalised node array and nothing else. Never object
  * identity, never insertion order of a Map, never a JSON stringify whose key

package/src/lang/README.md

@@ -28,12 +28,12 @@ const plasma = parse(source, { file: "plasma.sl" })
 written, and the two produce the same graph. `parity.test.ts` asserts that as
 hash equality for every GPU fixture and for the example on play.onejs.com: same
 hash means same generated shader and same pixels, established without rendering
-anything. It also means the existing GPU fixtures, the codegen goldens and the
-C# VM tests cover the text form for free, because they run on the IR.
+anything. It also means the existing GPU fixtures and the codegen goldens
+cover the text form for free, because they run on the IR.
 
 If that property ever breaks, the failure is silent in the worst way: a program
-whose hash does not match its generated shader falls back to the VM and nobody
-is told. So parity is the test to keep green, not the parser's unit tests.
+whose hash does not match its generated shader draws nothing in a native
+player. So parity is the test to keep green, not the parser's unit tests.
 
 | File | What it does |
 |---|---|
@@ -49,8 +49,8 @@ is told. So parity is the test to keep green, not the parser's unit tests.
 
 ## The loader
 
-`slPlugin()`, in onejs-unity's `onejs-unity/esbuild`, parses and encodes at BUILD TIME, so an import resolves to a small
-object of numbers and the bundle carries neither the parser nor the source. A
+`slPlugin()`, in onejs-unity's `onejs-unity/esbuild`, parses and compiles at BUILD TIME, so an import resolves to a small
+object of names, defaults and shader sources and the bundle carries neither the parser nor the source. A
 parse error becomes an esbuild error with the file, line and column, which the
 Play editor surfaces and every terminal editor links.
 
@@ -158,16 +158,12 @@ recorded gap, not an oversight, and each has its own error message rather than
 
 | | Why |
 |---|---|
-| `rgb2hsv`, `tex2Dlod` | The opcodes are numbered and **neither backend implements them**. Writing one would render as whatever the VM's dispatch falls through to and fail outright in the HLSL emitter. |
+| `rgb2hsv`, `tex2Dlod` | The opcodes are numbered and **no backend implements them**; every emitter throws on them. |
 | `fbm`'s simplex base | `sl.fbm(p, octaves, "simplex")` picks the base with a string, and the language has no strings. `fbm(p, octaves)` is the value base, and `turbulence` and `ridged` are the simplex family. |
 
-Related, and worth knowing: **the EDSL lets a program declare 15 textures and
-the VM has 4.** `ir.ts` picked its ceiling from the WebGL2 sampler count rather
-than from `FxProgram.shader`, which declares `_Tex0` to `_Tex3` and samples
-`_Tex3` for every slot past it, so slots 4 and up are silently wrong in the
-browser and correct after an eject. A `.sl` file is held to the real number, 4,
-reported at the declaration. The EDSL's ceiling is untouched here because
-lowering it changes recorded behaviour rather than parser behaviour.
+A `.sl` file and the EDSL are held to the same caps, `UNIFORM_SLOTS` (16) and
+`TEXTURE_SLOTS` (4), reported at the declaration in one wording (`ir.ts`'s
+`tooManyUniforms` and `tooManyTextures`).
 
 ## Attributes